Alpaca Wallet
Extension API

Connect to the wallet and get the active account address. The wallet must be unlocked — if locked, the user will be prompted to unlock it.

const { address, connected } = await window.alpaca.connect();

{
  address: "keeta_abc123...",  // Active wallet address
  connected: true              // Always true on success
}

Disconnect the wallet. Locks the session and clears the active connection. Triggers the disconnect event.

await window.alpaca.disconnect();

{ disconnected: true }

Lightweight check — returns the current connection state without triggering a connect flow. Use this to restore UI state on page load.

const { connected, address } = await window.alpaca.isConnected();
if (connected) {
  // Restore connected UI, address is available
}

{
  connected: true,
  address: "keeta_abc123..."  // null if not connected
}

Returns the network the wallet is currently configured for. Always pass this network value through your service calls — never assume mainnet.

const { network } = await window.alpaca.getNetwork();
// network: "main" or "test"

{ network: "main" }

Query on-chain balances. Pass a token address for a single token, or omit it to get all balances. Returns raw BigInt strings — apply the token's decimal places before displaying.

Single token

const result = await window.alpaca.getBalance("keeta_anqdi...");

{
  address: "keeta_abc123...",     // Wallet address
  network: "main",
  tokenAddress: "keeta_anqdi...", // Queried token
  balance: "1500000000000000000"  // Raw BigInt string
}

All balances

const result = await window.alpaca.getBalance();

{
  address: "keeta_abc123...",
  network: "main",
  balances: [
    { tokenAddress: "keeta_anqdi...", balance: "1500000000000000000" },
    { tokenAddress: "keeta_ao55q...", balance: "50000000000000000000" }
  ]
}

Sign an arbitrary UTF-8 message with the active account's private key. Useful for proof-of-ownership, login challenges, or off-chain attestations. The private key never leaves the extension.

const { signature, address } = await window.alpaca.signMessage("Login to MyDapp");

{
  signature: "a1b2c3d4...",  // Hex-encoded detached signature
  address: "keeta_abc123..."   // Signer address
}

Sign a transaction block without broadcasting it. Your backend is responsible for submitting the signed block to the network. Supports three transaction types.

const signedBase64 = await window.alpaca.signTransaction({
  type: "SWAP",
  params: {
    network:        "main",
    poolAddress:    "keeta_pool...",   // Pool account address
    tokenIn:        "keeta_token1...", // Token being sent
    tokenOut:       "keeta_token2...", // Token being received
    amountIn:       "1000000000000000000", // Raw amount in
    minAmountOut:   "950000000000000000",  // Slippage-protected minimum
    estimatedFees:  "50000000000000000",   // Network fee amount
    feeToken:       "keeta_kta..."      // Fee token address (usually KTA)
  }
});
// Returns: "base64-encoded-signed-block"

"eyJhbGciOi..."  // Base64-encoded signed block — submit to your backend

const signedBase64 = await window.alpaca.signTransaction({
  type: "SEND",
  params: {
    network: "main",
    to:      "keeta_recipient...",
    token:   "keeta_token...",
    amount:  "5000000000000000000"
  }
});
// Returns: "base64-encoded-signed-block"

const { base64, hash } = await window.alpaca.signTransaction({
  type: "FUND",
  params: {
    network:  "main",
    to:       "keeta_recipient...",
    token:    "keeta_token...",
    amount:   "100000000000000000",
    previous: "abc123..."  // Optional: chain to a prior block hash
  }
});

{
  base64: "eyJhbGciOi...",  // Signed block (not broadcast)
  hash: "def456..."         // Block hash (use as 'previous' for chaining)
}

Sign and broadcast in one step. The extension builds the block, signs it, and publishes it directly to the Keeta network. Use this for simple sends where your backend doesn't need to orchestrate the publish.

const { txHash } = await window.alpaca.sendTransaction({
  type: "SEND",
  params: {
    network: "main",
    to:      "keeta_recipient...",
    token:   "keeta_token...",
    amount:  "5000000000000000000"
  }
});
// txHash: "abc123..."  — transaction hash on Keeta

{ txHash: "abc123..." }