@console-wallet/dapp-sdk 0.0.17

package/README.md

@@ -0,0 +1,153 @@
+# 🧩 Console DApp SDK
+
+> A lightweight SDK for connecting your Web3 applications to the **Console Wallet Extension** — enabling account access, connection status, message signing, and sending **Canton Coin** with ease.
+
+---
+
+## 🚀 Overview
+
+**Console DApp SDK** is a developer-friendly library that allows any decentralized application (DApp) to seamlessly integrate with the **Console Wallet** browser extension.
+
+It provides simple APIs to:
+
+- 🔗 **Connect** your DApp to a user’s Console Wallet
+- 👤 **Access** the active account and connection state
+- ✍️ **Request message signing** to the wallet
+- 💰 **Send Canton Coin** transactions securely and reliably
+
+With just a few lines of code, you can authenticate users, sign data, or trigger Canton blockchain transactions — all through a unified SDK built for simplicity and safety.
+
+---
+
+## ⚙️ Key Features
+
+| Feature                    | Description                                                    |
+| -------------------------- | -------------------------------------------------------------- |
+| 🔌 **Easy Integration**    | One SDK import connects your app to Console Wallet instantly   |
+| 👛 **Account Access**      | Retrieve connected account address and chain info              |
+| 🧾 **Message Signing**     | Sign arbitrary messages or typed data directly from the wallet |
+| 💸 **Transaction Support** | Send Canton Coin with a simple API call                        |
+| 🔒 **Secure by Design**    | Uses wallet’s native permissions and confirmation flows        |
+| 🧠 **Framework Agnostic**  | Works with React, Vue, or vanilla JS apps                      |
+
+---
+
+## 🧠 Why Use Console DApp SDK?
+
+Instead of manually handling RPC connections or building custom wallet logic, `console-wallet-dapp-templ` provides a **clean, unified interface** for interacting with the Canton ecosystem.
+
+It’s ideal for:
+
+- Light start with Canton blockchain
+- Web3 DApps that need wallet connection and signing
+- Any app that interacts with Canton
+
+---
+
+## 🧠 Core Functionality
+
+The **Console DApp SDK** provides a communication layer between your Web3 application and the **Console Wallet Extension** using the browser’s native `window.postMessage` API.
+
+It handles all low-level messaging logic automatically, so you can focus on building your DApp — not managing communication details.
+
+### 🔄 How It Works
+
+1. When your DApp sends a request (e.g., `connect()`, `signMessage()`, or `sendTransaction()`),  
+   the SDK transmits a structured message to the **Console Wallet Extension** via `window.postMessage`.
+
+2. Each outgoing request is assigned a **unique request ID**, which is included in both the request and the extension’s response.
+
+3. The SDK listens for incoming responses from the extension, matches them to their original request using the ID,  
+   and automatically resolves the corresponding Promise in your application.
+
+This approach ensures **reliable, asynchronous communication** between the DApp and the extension — preventing race conditions, mismatched responses, or orphaned message handlers.
+
+### 🧩 Benefits
+
+- ✅ Fully **type-safe and asynchronous** API
+- 🧭 No manual message listeners required
+- 🛡️ Prevents **response mismatch errors** with per-request unique IDs
+- ⚡ Lightweight and dependency-free
+- 🧠 Extensible for future Console Wallet capabilities (multi-chain support, session management, etc.)
+
+---
+
+> In short: the SDK abstracts all the complex message passing between your DApp and the wallet, providing a **stable and predictable communication layer** out of the box.
+
+## 📡 Supported Requests
+
+The SDK exposes several high-level request methods that communicate with the **Console Wallet Extension** through secure message passing.  
+Each request is automatically tagged with a **unique request ID** to ensure reliable response matching.
+
+| Method                 | Description                                                    | Request Payload                   | Response                |
+| ---------------------- | -------------------------------------------------------------- | --------------------------------- | ----------------------- |
+| `getAccounts()`        | Retrieves the currently connected wallet account(s).           | —                                 | `GetAccountsResponse`   |
+| `signMessage(message)` | Requests the user to sign a message in hex or base 64 format.  | `{ message: SignMessageRequest }` | `SignedMessageResponse` |
+| `signSend(data)`       | Signs and broadcasts a transaction to send **Canton Coin**.    | `SignSendRequest`                 | `SignSendResponse`      |
+| `connect(data)`        | Prompts the users to connect their Console Wallet to the DApp. | `ConnectRequest`                  | `boolean`               |
+| `getIsConnected()`     | Checks if the DApp is already connected to the wallet.         | —                                 | `boolean`               |
+
+---
+
+### 🪄 Example
+
+```js
+const handleSignSend = async () => {
+  if (!amount || !receiver || !expireDate) {
+    alert('Please fill all fields');
+    return;
+  }
+
+  try {
+    const activeAccount = await consoleWalletPixelplex.getAccounts();
+    const signResult = await consoleWalletPixelplex.signSend({
+      to: receiver,
+      from: activeAccount?.[0].party || '',
+      amount,
+      expireDate,
+    });
+
+    setResult(signResult.status ? 'Transaction signed successfully' : 'Transaction error');
+  } catch (error) {
+    console.error('Error signing transaction:', error);
+    setResult('Error signing transaction');
+  }
+};
+```
+
+## 📦 Installation
+
+```bash
+npm install console-wallet-dapp-templ
+# or
+yarn add console-wallet-dapp-templ
+
+```
+
+Before your DApp can interact with the **Console Wallet Extension**, it needs to **initialize a connection session**.  
+This step establishes secure communication between your web application and the user’s wallet.
+
+### 🔌 Connecting Your DApp
+
+The SDK provides a simple `connect()` method that requests permission from the user’s Console Wallet.
+
+```js
+import { consoleWalletPixelplex } from 'console-wallet-dapp-templ';
+
+const handleConnect = async () => {
+  try {
+    await consoleWalletPixelplex.connect({ name, icon });
+  } catch (error) {
+    console.error('Error checking connection:', error);
+  }
+};
+
+const handleCheckConnection = async () => {
+  try {
+    const isConnected = await consoleWalletPixelplex.getIsConnected();
+    setConnectionStatus(isConnected ? 'Connected' : 'Not connected');
+  } catch (error) {
+    console.error('Error checking connection:', error);
+  }
+};
+```

package/dist/cjs/api/generated-wallet-api.d.ts

@@ -0,0 +1,417 @@
+export interface AllocationSummaryDTO {
+    allocate_before: string;
+    amount: string;
+    contract_id: string;
+    event_id: string;
+    executor: string;
+    receiver: string;
+    sender: string;
+    settle_before: string;
+    status: string;
+}
+export interface AmuletDTO {
+    amulet_balance: string;
+    locked_amulet_balance: string;
+}
+export interface BalanceDTO {
+    accumulated_holding_fees_locked: string;
+    accumulated_holding_fees_total: string;
+    accumulated_holding_fees_unlocked: string;
+    computed_as_of_round: number;
+    computed_as_of_time: string;
+    party_id: string;
+    total_available_coin: string;
+    total_coin_holdings: string;
+    total_locked_coin: string;
+    total_unlocked_coin: string;
+}
+export interface CreateTapDTO {
+    amount: string;
+    partyId: string;
+    privateKey: string;
+}
+export interface GetOffersSearchResponseDTO {
+    data: OfferDTO[];
+    next_cursor: string | null;
+}
+export interface GetPartyDetailsResponseDTO {
+    amulets: AmuletDTO;
+    balance: BalanceDTO;
+    in_pending_offers_count: number;
+    out_pending_offers_count: number;
+    party_id: string;
+    total_merge_split_burn_fee: string;
+    total_merge_split_count: number;
+    total_transfer_allocation_count: number;
+    total_transfer_allocation_count_as_receiver: number;
+    total_transfer_allocation_count_as_sender: number;
+    total_transfer_burn_fee: string;
+    total_transfer_command_count: number;
+    total_transfer_command_count_as_receiver: number;
+    total_transfer_command_count_as_sender: number;
+    total_transfer_count_as_receiver: number;
+    total_transfer_count_as_sender: number;
+    total_transfer_instruction_count: number;
+    total_transfer_instruction_count_as_receiver: number;
+    total_transfer_instruction_count_as_sender: number;
+    total_transfers_count: number;
+    validator_license: ValidatorLicenseDTO;
+}
+export interface GetPendingTransactionsResponseDTO {
+    items: object[];
+}
+export interface GetPricesResponseDTO {
+    current: string | null;
+    one_day_ago: string | null;
+    one_month_ago: string | null;
+    one_week_ago: string | null;
+    one_year_ago: string | null;
+    start_of_day: string | null;
+}
+export interface GetTokenTransfersByPartyResponseDTO {
+    data: TokenTransferItemDTO[];
+    next_cursor: string | null;
+}
+export interface GetTransferDetailsResponseDTO {
+    data: TransferAllocationResponseDTO | TransferInstructionResponseDTO | TransferPreApprovedInstructionResponseDTO | TransferOtherResponseDTO;
+}
+export interface InstructionSummaryDTO {
+    amount: string;
+    contract_id: string | null;
+    event_id: string;
+    execute_before: string;
+    executed_at: string | null;
+    receiver: string;
+    sender: string;
+    status: string;
+}
+export interface ListUtxosResponseDTO {
+    utxos: string[];
+}
+export interface MetadataDTO {
+    'splice.lfdecentralizedtrust.org/burned': string;
+    'splice.lfdecentralizedtrust.org/sender': string;
+    'splice.lfdecentralizedtrust.org/tx-kind': string;
+}
+export interface OfferDTO {
+    amount: string;
+    contract_id: string | null;
+    event_id: string;
+    offer_type: string;
+    receiver_party_id: string;
+    record_time: string;
+    sender_party_id: string;
+    status: string;
+}
+export interface PrepareExternalPartyBodyDTO {
+    partyHint?: string;
+    publicKey: string;
+}
+export interface PrepareExternalPartyResponseDTO {
+    preparedParty: PreparedExternalPartyResponseDTO;
+}
+export interface PrepareResolveTransferBodyDTO {
+    choice: 'Accept' | 'Reject' | 'Withdraw';
+    partyId: string;
+    transferCid: string;
+}
+export interface PrepareResolveTransferResponseDTO {
+    preparedSubmission: PreparedSubmissionResponseDTO;
+    submissionId: string;
+}
+export interface PrepareTransferBodyDTO {
+    amount: string;
+    /** @format date-time */
+    expiryDate: string;
+    receiver: string;
+    sender: string;
+}
+export interface PrepareTransferResponseDTO {
+    hashingDetails: string;
+    hashingSchemeVersion: string;
+    preparedTransaction: string;
+    preparedTransactionHash: string;
+    submissionId: string;
+}
+export interface PreparedExternalPartyBodyDTO {
+    combinedHash: string;
+    namespace: string;
+    partyId: string;
+    partyTransactions: string[];
+    txHashes: string[];
+}
+export interface PreparedExternalPartyResponseDTO {
+    combinedHash: string;
+    namespace: string;
+    partyId: string;
+    partyTransactions: string[];
+    txHashes: string[];
+}
+export interface PreparedSubmissionBodyDTO {
+    hashingDetails: string | null;
+    hashingSchemeVersion: string;
+    preparedTransaction: string;
+    preparedTransactionHash: string;
+}
+export interface PreparedSubmissionResponseDTO {
+    hashingDetails: string;
+    hashingSchemeVersion: string;
+    preparedTransaction: string;
+    preparedTransactionHash: string;
+}
+export interface ProxyRequestDTO {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    pathTemplate: '/explore/prices' | '/offers/search' | '/parties/{party_id}' | '/token-transfers/by-party' | '/api/v1/token-transfers/{event_id}';
+    payload?: string;
+}
+export interface SpentDTO {
+    receivers: SpentReceiverItemDTO[];
+    sender_send: string;
+    total_change_fee: string;
+    total_fee: string;
+    total_holder_fee: string;
+    total_output_fee: string;
+}
+export interface SpentReceiverItemDTO {
+    amount: string;
+    receiver: string;
+}
+export interface SubmitExternalPartyBodyDTO {
+    preparedParty: PreparedExternalPartyBodyDTO;
+    signedHash: string;
+}
+export interface SubmitExternalPartyResponseDTO {
+    partyId: string;
+}
+export interface SubmitResolveTransferBodyDTO {
+    preparedSubmission: PreparedSubmissionBodyDTO;
+    publicKey: string;
+    signature: string;
+    submissionId: string;
+}
+export interface SubmitTransferBodyDTO {
+    preparedTransfer: PrepareTransferResponseDTO;
+    publicKey: string;
+    signature: string;
+}
+export interface TokenTransferDataDTO {
+    holding_fee: string;
+    input_amount: string;
+    metadata: MetadataDTO;
+    provider: string;
+    receivers: TransferDataReceiversDTO;
+    round: number;
+    sender: string;
+    sender_change_amount: string;
+    sender_change_fee: string;
+}
+export interface TokenTransferItemDTO {
+    event_id: string;
+    record_time: string;
+    spent: SpentDTO;
+    transfer_data: TokenTransferDataDTO;
+    transfer_type: string;
+}
+export interface TrafficStatusDTO {
+    last_updated: string | null;
+    total_consumed: number;
+    total_limit: number;
+    total_purchased: number;
+    usage_percent: number;
+}
+export interface TransferAllocationDTO {
+    first_step: TransferStepDTO;
+    second_step: TransferStepDTO | null;
+    spent: SpentDTO;
+    summary: AllocationSummaryDTO;
+}
+export interface TransferAllocationResponseDTO {
+    allocation: TransferAllocationDTO;
+}
+export type TransferDataReceiversDTO = object;
+export interface TransferInstructionDTO {
+    first_step: TransferStepDTO;
+    second_step: TransferStepDTO | null;
+    spent: SpentDTO;
+    summary: InstructionSummaryDTO;
+}
+export interface TransferInstructionResponseDTO {
+    instruction: TransferInstructionDTO;
+}
+export interface TransferOtherDTO {
+    finalized_step: TransferStepDTO;
+    spent: SpentDTO;
+}
+export interface TransferOtherResponseDTO {
+    other: TransferOtherDTO;
+}
+export interface TransferPreApprovedInstructionDTO {
+    finalized_step: TransferStepDTO;
+    spent: SpentDTO;
+    summary: InstructionSummaryDTO;
+}
+export interface TransferPreApprovedInstructionResponseDTO {
+    preapproved_instruction: TransferPreApprovedInstructionDTO;
+}
+export interface TransferStepDTO {
+    event_id: string;
+    record_time: string;
+    transfer_data: TokenTransferDataDTO;
+    transfer_type: string;
+    update_id: string;
+}
+export interface ValidatorLicenseDTO {
+    active: boolean;
+    amulet_balance: string;
+    contact: string | null;
+    contract_id: string;
+    dso: string;
+    first_round: number;
+    last_active_at: string | null;
+    last_round: number;
+    metadata_last_update: string | null;
+    miss_round: number;
+    participated_updates_count: number;
+    sponsor: string;
+    template_id: string;
+    traffic_status: TrafficStatusDTO;
+    transfers_count: number;
+    validator_id: string;
+    version: string | null;
+}
+import type { AxiosInstance, AxiosRequestConfig, ResponseType } from 'axios';
+export type QueryParamsType = Record<string | number, any>;
+export interface FullRequestParams extends Omit<AxiosRequestConfig, 'data' | 'params' | 'url' | 'responseType'> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseType;
+    /** request body */
+    body?: unknown;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, 'data' | 'cancelToken'> {
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+    secure?: boolean;
+    format?: ResponseType;
+}
+export declare enum ContentType {
+    Json = "application/json",
+    JsonApi = "application/vnd.api+json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    instance: AxiosInstance;
+    private securityData;
+    private securityWorker?;
+    private secure?;
+    private format?;
+    constructor({ securityWorker, secure, format, ...axiosConfig }?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig;
+    protected stringifyFormItem(formItem: unknown): string;
+    protected createFormData(input: Record<string, unknown>): FormData;
+    request: <T = any, _E = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<T>;
+}
+/**
+ * @title 869-wallet-extension-backend
+ * @version 0.0.1
+ * @contact
+ */
+export declare class WalletApi<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    api: {
+        /**
+         * No description
+         *
+         * @tags external-party
+         * @name ExternalPartyControllerPrepareExternalParty
+         * @request POST:/api/v1/external-party/prepare
+         */
+        externalPartyControllerPrepareExternalParty: (data: PrepareExternalPartyBodyDTO, params?: RequestParams) => Promise<PrepareExternalPartyResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags external-party
+         * @name ExternalPartyControllerSubmitExternalParty
+         * @request POST:/api/v1/external-party/submit
+         */
+        externalPartyControllerSubmitExternalParty: (data: SubmitExternalPartyBodyDTO, params?: RequestParams) => Promise<SubmitExternalPartyResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags proxy
+         * @name ProxyIndexerControllerProxy
+         * @request POST:/api/v1/proxy/indexer
+         */
+        proxyIndexerControllerProxy: (data: ProxyRequestDTO, params?: RequestParams) => Promise<GetOffersSearchResponseDTO | GetPartyDetailsResponseDTO | GetPricesResponseDTO | GetTokenTransfersByPartyResponseDTO | GetTransferDetailsResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TokenStandardControllerCreateTap
+         * @request POST:/api/v1/token-standard/tap
+         */
+        tokenStandardControllerCreateTap: (data: CreateTapDTO, params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TokenStandardControllerGetPendingTransactions
+         * @request GET:/api/v1/token-standard/transactions/pending
+         */
+        tokenStandardControllerGetPendingTransactions: (query: {
+            partyId: string;
+        }, params?: RequestParams) => Promise<GetPendingTransactionsResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TokenStandardControllerListUtxoHoldings
+         * @request GET:/api/v1/token-standard/utxo-holdings
+         */
+        tokenStandardControllerListUtxoHoldings: (query: {
+            partyId: string;
+        }, params?: RequestParams) => Promise<ListUtxosResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TransferControllerPrepareResolveTransfer
+         * @request POST:/api/v1/token-standard/transfer/resolve/prepare
+         */
+        transferControllerPrepareResolveTransfer: (data: PrepareResolveTransferBodyDTO, params?: RequestParams) => Promise<PrepareResolveTransferResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TransferControllerPrepareTransfer
+         * @request POST:/api/v1/token-standard/transfer/prepare
+         */
+        transferControllerPrepareTransfer: (data: PrepareTransferBodyDTO, params?: RequestParams) => Promise<PrepareTransferResponseDTO>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TransferControllerSubmitResolveTransfer
+         * @request POST:/api/v1/token-standard/transfer/resolve/submit
+         */
+        transferControllerSubmitResolveTransfer: (data: SubmitResolveTransferBodyDTO, params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags token-standard
+         * @name TransferControllerSubmitTransfer
+         * @request POST:/api/v1/token-standard/transfer/submit
+         */
+        transferControllerSubmitTransfer: (data: SubmitTransferBodyDTO, params?: RequestParams) => Promise<void>;
+    };
+}