Comprehensive type definitions used throughout the Wallets SDK.
Core Types
Chain
type Chain = EVMChain | SolanaChain | StellarChain
type EVMChain =
| "ethereum"
| "polygon"
| "base"
| "arbitrum"
| "optimism"
| "bsc"
| "avalanche"
// ... and other EVM chains
type SolanaChain = "solana"
type StellarChain = "stellar"
WalletArgsFor<C>
type WalletArgsFor<C extends Chain> = {
chain: C;
signer: SignerConfigForChain<C>;
owner?: string;
plugins?: WalletPlugin<C>[];
options?: WalletOptions;
delegatedSigners?: Array<DelegatedSigner>;
alias?: string;
}
signer
SignerConfigForChain<C>
required
Signer configuration for authentication
Optional owner identifier
Optional wallet configuration
Optional delegated signers
WalletOptions
type WalletOptions = {
experimental_callbacks?: Callbacks;
clientTEEConnection?: HandshakeParent<
typeof signerOutboundEvents,
typeof signerInboundEvents
>;
}
Lifecycle callbacks
Called when wallet creation starts
Called when transaction starts
Trusted execution environment connection
Balance Types
Balances<C>
type Balances<C extends Chain = Chain> = {
nativeToken: TokenBalance<C>;
usdc: TokenBalance<C>;
tokens: TokenBalance<C>[];
}
TokenBalance<C>
type TokenBalance<C extends Chain = Chain> = {
symbol: "sol" | "eth" | "usdc" | string;
name: string;
amount: string;
decimals?: number;
rawAmount?: string;
} & ChainExtras[ChainToExtrasKey<C>]
// Chain-specific extras:
// For EVM: { contractAddress?: string }
// For Solana: { mintHash?: string }
// For Stellar: { contractId?: string }
Token symbol (e.g., “eth”, “usdc”)
Formatted amount in decimal units
Raw amount in smallest unit (wei, lamports, stroops)
EVM only: Token contract address
Solana only: SPL token mint address
Stellar only: Token contract ID
Transaction Types
Transaction<TPrepareOnly>
type Transaction<TPrepareOnly extends boolean = false> =
TPrepareOnly extends true
? {
hash?: string;
explorerLink?: string;
transactionId: string;
}
: {
hash: string;
explorerLink: string;
transactionId: string;
}
prepareOnly is true.
type TransactionInputOptions = PrepareOnly & {
experimental_signer?: string;
}
type PrepareOnly<T extends boolean = boolean> = {
experimental_prepareOnly: T;
}
If true, creates transaction without auto-approving
SendTokenTransactionOptions
type SendTokenTransactionOptions = TransactionInputOptions & {
transactionType?: SendTokenTransactionType;
}
type SendTokenTransactionType = "onramp" | "regulated-transfer" | "direct"
UserLocator
type UserLocator =
| { email: string }
| { x: string }
| { twitter: string }
| { phone: string }
| { userId: string }
EVM-Specific Types
type EVMTransactionInput = EVMTransactionInputBase &
(
| {
to: string;
functionName?: string;
args?: unknown[];
value?: bigint;
abi?: Abi;
data?: `0x${string}`;
}
| { transaction: string }
)
type EVMTransactionInputBase = {
options?: TransactionInputOptions;
}
type FormattedEVMTransaction =
| {
to: string;
value: string;
data: string;
}
| { transaction: string }
Signature Types
Signature<TPrepareOnly>
type Signature<TPrepareOnly extends boolean = false> =
TPrepareOnly extends true
? {
signature?: string;
signatureId: string;
}
: {
signature: string;
signatureId: string;
}
signature is optional if prepareOnly is true.
type SignMessageInput = {
message: string;
options?: SignatureInputOptions;
}
type SignatureInputOptions = PrepareOnly
type SignTypedDataInput = TypedDataDefinition<TypedData, string> & {
chain: EVMSmartWalletChain;
options?: SignatureInputOptions;
}
Solana-Specific Types
import type { Keypair, VersionedTransaction } from "@solana/web3.js";
type SolanaTransactionInput = (
| {
transaction: VersionedTransaction;
}
| {
serializedTransaction: string;
}
) & {
additionalSigners?: Keypair[];
options?: TransactionInputOptions;
}
Stellar-Specific Types
type StellarTransactionInput = (
| {
contractId: string;
method: string;
memo?: string;
args: Record<string, any>;
}
| {
transaction: string;
contractId: string;
}
) & {
options?: TransactionInputOptions;
}
Approval Types
ApproveParams
type ApproveParams = {
transactionId?: string;
signatureId?: string;
options?: ApproveOptions;
}
ApproveOptions
type ApproveOptions = {
experimental_approval?: Approval;
additionalSigners?: Signer[];
}
ApproveResult<T>
type ApproveResult<T extends ApproveParams> =
T extends { transactionId: string }
? Transaction<false>
: T extends { signatureId: string }
? Signature<false>
: Error
Approval
type Approval = (BaseSignResult | PasskeySignResult) & {
signer: string;
}
Delegated Signer Types
DelegatedSigner
type DelegatedSigner = {
signer: string;
}
external-wallet:address.
AddDelegatedSignerOptions
type AddDelegatedSignerOptions = PrepareOnly
AddDelegatedSignerReturnType<C>
type AddDelegatedSignerReturnType<C extends Chain> =
C extends "solana" | "stellar"
? { transactionId: string }
: { signatureId: string }
prepareOnly with addDelegatedSigner().
Activity Types
Activity
type Activity = WalletsV1Alpha2ActivityResponseDto
Example Usage
import type {
Chain,
WalletArgsFor,
Transaction,
Balances,
UserLocator,
EVMTransactionInput,
SolanaTransactionInput,
StellarTransactionInput
} from "@crossmint/wallets";
// Typed wallet creation
const walletArgs: WalletArgsFor<"ethereum"> = {
chain: "ethereum",
signer: {
type: "evm-keypair",
privateKey: "0x..."
}
};
// Typed transaction result
const tx: Transaction<false> = await wallet.send(
"0x...",
"usdc",
"10.0"
);
// Typed balances
const balances: Balances<"ethereum"> = await wallet.balances();
console.log(balances.nativeToken.amount); // ETH amount
// User locator
const recipient: UserLocator = { email: "[email protected]" };
await wallet.send(recipient, "usdc", "5.0");
// Chain-specific transactions
const evmTx: EVMTransactionInput = {
to: "0x...",
value: 1000000000000000000n, // 1 ETH in wei
data: "0x"
};
const solanaTx: SolanaTransactionInput = {
serializedTransaction: "base58-encoded-tx"
};
const stellarTx: StellarTransactionInput = {
contractId: "CONTRACT_ID",
method: "transfer",
args: { to: "GCEXAMPLE...", amount: 1000000 }
};
Related Pages