Skip to main content

Starknet Support

Keplr enables seamless interaction with Starknet. Developers can access the Starknet provider through the starknet object, which is a member of the Keplr instance object. Also, developers can use the starknet_keplr available in the web window object. Throughout this documentation, we refer to these objects as keplr and keplr.starknet.

Enabling Connection​

To interact with EVM-based chains, you first need to call the keplr.starknet.enable method, which prompts the user for permission via a popup.

enable(): Promise<void>
Starknet Enable Chain Example Image

Signing Transactions on Starknet​

Requesting a Starknet Signature​

To request a Starknet signature, use the keplr.signStarknetTx method. This method returns a promise that resolves to an object containing the signed transactions and signer details.

signStarknetTx(
    chainId: string,
    transactions: Call[],
    details: InvocationsSignerDetails
): Promise<{
    transactions: Call[];
    details: InvocationsSignerDetails;
    signature: string[];
}>

Signing a Starknet Deploy Account Transaction​

To start interacting with Starknet, users must create an account, which requires a signature. Use the keplr.signStarknetDeployAccountTransaction method to sign a deploy account transaction.

signStarknetDeployAccountTransaction(
    chainId: string,
    transaction: DeployAccountSignerDetails
): Promise<{
    transaction: DeployAccountSignerDetails;
    signature: string[];
}>

Retrieving Starknet Keys​

You can retrieve Starknet keys and addresses using the following methods:

type Key = {
  name: string;
  hexAddress: string;
  pubKey: Uint8Array;
  address: Uint8Array;
  isNanoLedger: boolean;
};

// Get the Starknet key for a single chain
getStarknetKey(chainId: string): Promise<Key>;

// Get Starknet keys for multiple chains
getStarknetKeysSettled(
  chainIds: string[]
): Promise<SettledResponses<Key>>;

Starknet JSON-RPC Requests​

The keplr.starknet.request method enables you to send Starknet JSON-RPC requests. This method supports various request types, which may require specific parameters.

request<T = unknown>({
  type,
  params,
}: {
  type: string;
  params?: unknown[] | Record<string, unknown>;
}): Promise<T>;

Supported Request Types​

  • wallet_watchAsset: Suggest ERC20 tokens. 
    params: {
      type: "ERC20";
      options: {
        address: string
        symbol?: string
        decimals?: number
        image?: string
        name?: string
      };
    };
  • wallet_requestAccounts: Retrieve selected Starknet accounts.
  • wallet_getPermissions: Retrieve Starknet permissions.
  • wallet_switchStarknetChain: Switch the current chain. 
    params: [{ chainId: string }];
  • wallet_requestChainId: Retrieve the current chain ID.
  • wallet_addInvokeTransaction: Add a Starknet invoke transaction. 
    params: {
      calls: {
        contract_address: string
        entry_point: string
        calldata: RawArgs | Calldata
      }[]
    };
  • wallet_signTypedData: Sign Starknet typed data. 
    params: { message: StarknetTypedData };
  • wallet_supportedSpecs: Retrieve supported Starknet specifications.

Starknet-Native Request Types​

  • starknet_addDeclareTransaction, starknet_addDeployAccountTransaction, starknet_addInvokeTransaction, starknet_blockHashAndNumber, starknet_blockNumber, starknet_call, starknet_chainId, starknet_estimateFee, starknet_getBlockTransactionCount, starknet_getBlockWithTxHashes, starknet_getBlockWithTxs, starknet_getClass, starknet_getClassAt, starknet_getClassHashAt, starknet_getEvents, starknet_getNonce, starknet_getStateUpdate, starknet_getStorageAt, starknet_getTransactionByBlockIdAndIndex, starknet_getTransactionByHash, starknet_getTransactionReceipt, starknet_pendingTransactions, starknet_simulateTransactions, starknet_specVersion, starknet_syncing

For detailed information on Starknet JSON-RPC APIs, refer to the Starknet API OpenRPC.

Examples​

Suggesting ERC20 Tokens​

keplr.starknet.request({
  type: "wallet_watchAsset",
  params: {
    type: "ERC20",
    options: {
      address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7", // ETH Contract address
    },
  },
});

Switching Chains​

keplr.starknet.request({
  type: "wallet_switchStarknetChain",
  params: { chainId: "0x534e5f5345504f4c4941" },
});

Retrieving Transaction Information​

keplr.starknet.request({
  type: "starknet_getTransactionByHash",
  params: { transactionHash: "0x123456789abcdef" },
});

Events​

The Starknet provider offers event listeners to track changes in accounts and network.

accountsChanged​

Listen for changes to the user's exposed account address.

Interface​

interface KeplrStarknetProvider {
  on: (event: 'accountsChanged', handler: (accounts: Array<string>) => void) => void;
  off: (event: 'accountsChanged', handler: (accounts: Array<string>) => void) => void;
}

Example​

const handleAccountsChanged = (accounts) => {
  console.log('Accounts changed:', accounts);
};

// Add listener
window.keplr.starknet.on('accountsChanged', handleAccountsChanged);

// Remove listener
window.keplr.starknet.off('accountsChanged', handleAccountsChanged);

networkChanged​

Listen for changes to the current network.

Interface​

type StarknetChainId = 
  | "0x534e5f4d41494e"     // SN_MAIN - Starknet Mainnet
  | "0x534e5f5345504f4c4941"; // SN_SEPOLIA - Starknet Sepolia Testnet

interface KeplrStarknetProvider {
  on: (event: 'networkChanged', handler: (chainId: StarknetChainId) => void) => void;
  off: (event: 'networkChanged', handler: (chainId: StarknetChainId) => void) => void;
}

Example​

const handleNetworkChanged = (chainId) => {
  console.log('Network changed:', chainId);
};

// Add listener
window.keplr.starknet.on('networkChanged', handleNetworkChanged);

// Remove listener
window.keplr.starknet.off('networkChanged', handleNetworkChanged);