---
title: "Connect Canton dApps to wallets"
description: "A typed CIP-103 provider, RPC client, and React hooks for Canton Network, built and used in production by Send."
url: "https://sigilry.org/"
---

Sigilry is a [CIP-103](https://github.com/canton-foundation/cips/blob/main/cip-0103/cip-0103.md) compliant dApp connectivity library for Canton Network. It implements the CIP-103 dApp API as a typed JSON-RPC client/server pair, ships generated Zod schemas for runtime validation, and exposes React Query hooks for fast integration.

Install the stable SDK with `yarn add @sigilry/dapp@^3 @sigilry/react@^3`. Building with Send Connect? Start with [testnet connection](/guides/send-connect-testnet/), [message verification](/guides/verify-sign-message/), and [holdings queries](/guides/read-holdings/).

Sigilry is built and maintained by [Send](https://send.it) and used in production by Send’s Canton Network dApps.

## Start here

[Quick Start ](getting-started/quick-start/)Connect to an installed wallet extension and make your first CIP-103 request.

[Demo App ](getting-started/demo-app/)Run the full DAML → codegen → React flow locally, no extension required.

[Send Connect testnet ](guides/send-connect-testnet/)Install Send Connect, select Testnet, and verify the network from your dApp.

[CIP-103 Conformance ](concepts/cip-103-conformance/)Per-method conformance status, deviations, and versioning.

## Packages

@sigilry/dapp

Core provider, RPC client and server, message schemas, and transports. [Usage](packages/dapp/)

@sigilry/react

React Query powered hooks and `CantonReactProvider`. [Usage](packages/react/)

@sigilry/cli

CLI and programmatic API for generating TypeScript types from DAML DARs. [Usage](packages/cli/)

@sigilry/canton-json-api

Generated Canton JSON API v2 types and Zod schemas for typed ledger endpoint contracts. [Usage](packages/canton-json-api/)

## New to Canton?

Start with the [Demo App](getting-started/demo-app/) before package internals. It shows the full flow in one place:

1. DAML templates and choices (`TodoList` factory + `TodoItem` contracts)
2. DAR build and typed codegen via Sigilry CLI
3. dApp-side React hooks calling a typed `window.canton` provider
4. Event-driven wallet/ledger logs plus `txChanged` updates after approvals

Fastest way to run it from the repo root:

```bash
nix develop
yarn install
yarn --cwd examples/demo-app dev
```

Choose your starting path:

* Building a real dApp integration against an installed wallet extension: go to [Quick Start](getting-started/quick-start/).
* Learning the full flow locally without extension setup: go to [Demo App](getting-started/demo-app/).

## SDK Flow

The wallet extension injects a CIP-103 provider at `window.canton`. The provider object follows the EIP-1193 shape that CIP-103 itself specifies (`request` / `on` / `removeListener`), routes calls through typed JSON-RPC method names from the CIP-103 OpenRPC schema, and emits the full CIP-103 §4.2.2 push-event surface (`accountsChanged`, `txChanged`, `statusChanged`, `connected`) to signal wallet, ledger, and session/network state changes. Methods with void params omit the `params` field. See [CIP-103 Conformance](concepts/cip-103-conformance/) for the per-method conformance table, and the [@sigilry/dapp](packages/dapp/) and [@sigilry/react](packages/react/) pages for the full contract.

## Quick start

* Start with the basics in [Introduction](getting-started/introduction/).
* Follow the 10-minute integration in [Quick Start](getting-started/quick-start/).
* Run the full newcomer flow in [Demo App](getting-started/demo-app/).
* Go deeper in [Architecture](concepts/architecture/) and [RPC Protocol](concepts/rpc-protocol/).

## CLI Codegen

Use `sigilry init` to create `sigilry.config.ts`, then run `sigilry codegen` to generate TypeScript types. The CLI requires the DAML SDK so `dpm` is available, and it wraps `dpm codegen-alpha-typescript` under the hood. See the [@sigilry/cli](packages/cli/) page for the full configuration reference.

## Minimal dApp request

```ts
import "@sigilry/dapp/browser-globals";

export async function connectAndListAccounts() {
  if (!window.canton) {
    throw new Error("Canton provider not available");
  }

  const status = await window.canton.request({ method: "status" });
  if (!status.connection.isConnected) {
    await window.canton.request({ method: "connect" });
  }

  const accounts = await window.canton.request({ method: "listAccounts" });
  console.log("Accounts:", accounts);
  return accounts;
}
```

## Ledger API Patterns

`ledgerApi` requests map directly to Daml JSON Ledger API v2 endpoints. Hooks like `useLedgerApi` and `useActiveContracts` call `/v2/state/ledger-end` and `/v2/state/active-contracts` to resolve the current offset and fetch active contracts.

```ts
import "@sigilry/dapp/browser-globals";

if (!window.canton) throw new Error("Canton provider not available");

const ledgerEnd = await window.canton.request({
  method: "ledgerApi",
  params: {
    requestMethod: "get",
    resource: "/v2/state/ledger-end",
  },
});
console.log(ledgerEnd);
```

## Architecture at a glance

```plaintext
dApp UI
  -> window.canton (CIP-103 provider; EIP-1193 object shape)
  -> JSON-RPC (CIP-103 OpenRPC schema + Zod validation)
  -> WindowTransport (postMessage)
  -> Wallet extension (RPC server)
  -> Canton Ledger API / DAML
```

## For AI agents

* [`llms.txt`](/llms.txt) is a concise index; [`llms-full.txt`](/llms-full.txt) contains every page.
* Every page is available as Markdown: append `.md` to its URL, request it with `Accept: text/markdown`, or follow its `<link rel="alternate" type="text/markdown">`.
* Code samples on package, guide, and concept pages are compiled against the current packages in CI and include explicit CIP-103 method names.
* See [CIP-103 Conformance](concepts/cip-103-conformance/) for the per-method conformance table and the [API Reference](api-reference/readme/) for full signatures.