Types

AccountType

type AccountType = {
    provider: string,
    providerSupports: string[]|undefined,
    cspr_name: string | null,
    public_key: string | null,
    connected_at: Number,
    token: string | null,
    custom?: any,
    balance?: string,
    liquid_balance?: string;
    logo?: string;
}

Property	Description
provider	The provider to which the account belongs to.
providerSupports	An array of supported capabilities in the connected wallet. Possible values: "sign-deploy", "sign-transactionv1", "sign-message".
cspr_name	CSPR.name name
public_key	The public key.
connected_at	Timestamp for the initial connection of the account
token	n/a (for future use)
custom	Custom data. Depends on the provider.
balance	Total balance of the account in CSPR motes (includes liquid +staked balance)
liquid_balance	Liquid balance of the account in CSPR motes (includes liquid +staked balance)
logo	A URL to the account avatar or logo.

CsprClickInitOptions

type CsprClickInitOptions = {
    appName: string,
    appId: string,
    contentMode: 'iframe' | 'popup',
    casperNode?: string,
    chainName?: string,
    providers: Array<string>,
}

Property	Description
appName	The name of your app as it will be shown in the pop-up windows.
appId	An application identifier. Read more about it here.
contentMode	Defines whether the sign in interface is shown within an iframe in your application or in external pop-up windows.
casperNode	The RPC endpoint CSPR.click uses to get information from the Casper network and to send deploys.
chainName	Use casper or casper-test to interact with Casper Mainnet or Casper Testnet, respectively.
providers	The list of providers (wallets) you want to allow in your application

The wallets you can add to the providers array are:

• casper-wallet

• ledger

• metamask-snap

DecryptMessageResult

export type DecryptMessageResult = {
    cancelled: boolean;
    decryptedMessage: string | null;
    error: string | null;
}

Property	Description
cancelled	true when the user has declined the decryption of a message. false otherwise
decryptedMessage	String with the decrypted message.
error	null if the message has been successfully decrypted. It contains an error message otherwise..

EncryptMessageResult

export type EncryptMessageResult = {
    cancelled: boolean;
    encryptedMessage: string | null;
    error: string | null;
}

Property	Description
cancelled	true when the user has declined the encryption of a message. false otherwise
encryptedMessage	Hexadecimal string with the encrypted message bytes.
error	null if the message has been successfully encrypted. It contains an error message otherwise..

ProviderInfo

type ProviderInfo = {
    key: string,
    name: string,
    version: string,
    supports: Array<string>,
}

Property	Description
key	Internal name of the provider (wallet).
name	Friendly/Huma readable name of the provider.
version	Version of the provider. Only available for some wallets, when they're installed and/or connected.
supports	Array of keys of the features supported. The values returned may depend on the connected version of the provider. Currently, the possible supported features are: sign-deploy, sign-transactionv1, and sign-message.

SendResult

type SendResult = {
    cancelled: boolean,
    deployHash: string | null,
    transactionHash: string | null,
    error: string | null,
    errorData: object | null,
    status: string | null;
    csprCloudTransaction: any;
}

Property	Description
cancelled	true when the user has declined the signature of the transaction. false otherwise
deployHash	The hash of the deploy signed and sent to the Casper network. null when the deploy signature has been cancelled or there was an error sending it to the network
error	null if the deploy has been successfully signed and sent to the network. It contains an error message when the network rejects the deploy.
errorData	extra information on the error. It's usually a json object.
status	Indicates the status of the transaction sent. This property is helpful when used in combination with the `waitProcessing` in the `send()` method. Possible values: "sent", "processed", "created", "cancelled", "error", "timeout".
csprCloudTransaction	Raw json object returned by CSPR.cloud streaming API for a processed transaction. Check CSPR.cloud docs for detailed info on the contents.

SignResult

type SignResult = {
    cancelled: boolean,
    signatureHex: string | null,
    signature: Uint8Array | null,
    deploy: object | null,
    transaction: object | null,
    error: string | null,
}

Property	Description
cancelled	true when the user has declined the signature of the transaction. false otherwise
signatureHex	An hexadecimal string with the crytpographic signature of the deploy.
signature	A byte array with the cryptographic signature of the deploy.
deploy	A json object containing the deploy with the user approval entry (i.e., the new signature).
error	null if the deploy has been successfully signed. It contains an error message otherwise.

SignTypedDataParams

type SignTypedDataParams = {
    typedData: {
        domain: Record<string, unknown>;
        types: Record<string, Array<{ name: string; type: string }>>;
        primaryType: string;
        message: Record<string, unknown>;
    };
    options?: {
        domainTypes?: Array<{ name: string; type: string }>;
        returnHashArtifacts?: boolean;
        rejectUnknownFields?: boolean;
    };
}

Property	Description
typedData.domain	EIP-712 domain object (e.g. name, version, chain_name, and contract_package_hash).
typedData.types	Map of type names to their field definitions, following EIP-712 conventions.
typedData.primaryType	The top-level type to sign (must be a key in types).
typedData.message	The structured data object to sign, matching the schema of primaryType.
options.domainTypes	Optional explicit domain field definitions for hashing. When omitted, the wallet uses typedData.types.EIP712Domain if present.
options.returnHashArtifacts	When true, the response includes intermediate hash artifacts (domain separator, struct hash, etc.) in the hashArtifacts field of SignTypedDataResult.
options.rejectUnknownFields	When true, the wallet MUST reject the request if the message contains fields not declared in types.

Example:

{
    "typedData": {
        "domain": {
            "name": "Wrapped CSPR",
            "version": "1",
            "chain_name": "casper:casper-test",
            "contract_package_hash": "3d80df21ba4ee4d66a2a1f60c32570dd5685e4b279f6538162a5fd1314847c1e"
        },
        "types": {
            "TransferWithAuthorization": [
                {
                    "name": "from",
                    "type": "address"
                },
                {
                    "name": "to",
                    "type": "address"
                },
                {
                    "name": "value",
                    "type": "uint256"
                },
                {
                    "name": "validAfter",
                    "type": "uint256"
                },
                {
                    "name": "validBefore",
                    "type": "uint256"
                },
                {
                    "name": "nonce",
                    "type": "bytes32"
                }
            ]
        },
        "primaryType": "TransferWithAuthorization",
        "message": {
            "from": "00a13d2ae9e961c0f8abfca595d330511aa2b82acd8df6d1642dc80d3c7ca22977",
            "to": "00aa35d1c9dcaadea97c34d79b55b6af07aa9d760e5dd1aabf78a45fb39e0723fa",
            "value": 7500000000,
            "validAfter": 1780556982,
            "validBefore": 1780560582,
            "nonce": "17a0406a474c8dc0ac00889901001fdec05f21a0e204f99c8c5005c416bfe910"
        }
    },
    "options": {
        "returnHashArtifacts": true
    }
}

SignTypedDataResult

type SignTypedDataResult = {
    cancelled: boolean;
    signatureHex: string | null;
    digest: string | null;
    publicKey: string | null;
    error: string | null;
    errorCode?: SignTypedDataErrorCode;
    hashArtifacts?: EIP712HashArtifacts;
}

Property	Description
cancelled	true when the user has declined the signing operation. false otherwise.
signatureHex	Prefixed signature hex (01 for ed25519, 02 for secp256k1) followed by the signature bytes, or null if cancelled or failed.
digest	0x-prefixed 32-byte hex digest that was signed, or null if cancelled or failed.
publicKey	Prefixed public key used for signing, or null if cancelled or failed.
error	null if the operation succeeded. Contains an error message otherwise.
errorCode	Machine-readable error code. See SignTypedDataErrorCode for possible values.
hashArtifacts	Intermediate hash artifacts for debugging. Only present when returnHashArtifacts was true in the request options. See EIP712HashArtifacts.

SignTypedDataErrorCode

A string union of machine-readable error codes returned in SignTypedDataResult.

Value	Description
USER_REJECTED	The user declined the signing request.
INVALID_PARAMS	The request parameters are malformed or missing required fields.
UNSUPPORTED_TYPE	The wallet does not support the requested type definition.
DOMAIN_TYPES_REQUIRED	Domain type definitions are required but were not provided.
SIGNATURE_SCHEME_NOT_SUPPORTED	The account's key scheme is not supported for typed data signing.
ACCOUNT_NOT_FOUND	The requested account could not be found in the wallet.
NOT_AUTHORIZED	The wallet rejected the request due to an authorization failure.

EIP712HashArtifacts

Intermediate hashing artifacts returned in SignTypedDataResult when options.returnHashArtifacts is true.

type EIP712HashArtifacts = {
    domainTypeString?: string;
    domain?: Record<string, unknown>;
    domainSeparator?: string;
    canonicalTypeString?: string;
    typeHash?: string;
    structHash?: string;
}

Property	Description
domainTypeString	The encoded EIP-712 domain type string used for hashing.
domain	The domain object as used during hashing.
domainSeparator	0x-prefixed domain separator hash.
canonicalTypeString	Canonical type string for the primary type.
typeHash	0x-prefixed type hash.
structHash	0x-prefixed struct hash of the message.