# Kibisis Wallet

{% embed url="<https://github.com/headline-design/siwa-connect>" %}
Get started quickly with SIWA Connect
{% endembed %}

### Prerequisites

Install the Kibisis wallet extension on Chrome

### Overview

Kibisis wallet uses a direct message signing approach for SIWA messages. Here's how it works:

1. Inject the Kibisis wallet script
2. Enable the wallet and get the user's address
3. Sign the SIWA message using the wallet's `signBytes` method

### Implementation

#### 1. Injecting and Connecting to Kibisis Wallet

To use Kibisis wallet, you need to inject its script and enable it:

```javascript
const injectKibisis = async () => {
  if (typeof window === "undefined") {
    throw new Error("Kibisis is only available in the browser");
  }

  async function enableWallet() {
    if (!window.algorand) {
      console.error("AVM Wallets not available");
      return null;
    }

    try {
      const result = await window.algorand.enable("kibisis");
      console.log("Wallet enabled:", result);
      if (result.accounts && result.accounts.length > 0) {
        return result.accounts[0].address;
      } else {
        throw new Error("No accounts available");
      }
    } catch (error) {
      console.error("Error enabling wallet:", error);
      return null;
    }
  }

  let address = await enableWallet();
  if (address) {
    return address;
  } else {
    console.log("No address obtained or user cancelled.");
    throw new Error("User cancelled or no accounts available");
  }
};
```

#### 2. Signing a SIWA Message

To sign a SIWA message with Kibisis wallet:

1. Prepare the message by prefixing it with "MX"
2. Use the `window.algorand.signBytes` method to sign the message

Here's the code to accomplish this:

```javascript
const signMessage = async (message: string) => {
  if (!address) {
    throw new Error("No address connected");
  }

  const kibisisMessage = "MX" + JSON.stringify(message);
  const kibisisResult = await window.algorand.signBytes({
    data: new Uint8Array(Buffer.from(kibisisMessage)),
  });

  return {
    signature: kibisisResult?.signature,
    transaction: null,
  };
};
```

### Verification

When verifying the SIWA message signature for Kibisis wallet, the process is straightforward as it uses direct message signing. Here's how it works:

1. The verification function receives the following parameters:
   * `message`: The original SIWA message
   * `signature`: The signature in base64 format
   * `provider`: The wallet provider (in this case, "Kibisis")
2. The verification process for Kibisis wallet:

```javascript
if (provider === "Kibisis") {
  try {
    // Prepare hashed message bytes
    const hashedMessage = new Uint8Array(Buffer.from(JSON.stringify(message.prepareMessage())));

    // Decode the signature from base64 to Uint8Array
    const signatureUint8Array = Uint8Array.from(atob(signature).split("").map((char) => char.charCodeAt(0)));

    // Verify the signature using algosdk
    const isValid = algosdk.verifyBytes(hashedMessage, signatureUint8Array, message.address);

    return isValid;
  } catch (error) {
    return false; // Return false if any error occurs during verification
  }
}
```

This verification process ensures that:

1. The message is properly hashed
2. The signature is valid for the given message and address

Key points to remember for Kibisis wallet verification:

1. The message used for verification should be the same as the one used for signing (including the "MX" prefix).
2. The `algosdk.verifyBytes` function is used to verify the signature against the hashed message and the signer's address.
3. Any errors during the verification process will result in a `false` return value.

Remember to handle any potential errors during the verification process and ensure that all required parameters are provided.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.siwa.org/integrations/kibisis-wallet.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.