@temple-digital-group/temple-canton-js 2.0.6 → 2.1.0-beta.0

package/README.md

@@ -14,18 +14,19 @@ Call `initialize()` before using any SDK functions. It sets up the config and op
 
 ### Wallet Adapter
 
-For apps using Loop Wallet. Pass the Loop SDK instance as `WALLET_ADAPTER` — the SDK auto-detects server vs client mode.
+For apps using a supported wallet, pass the wallet instance as `WALLET_ADAPTER` or wrap it with the matching adapter factory.
 
-- **Server-side:** uses `loop.executeTransaction()` (signs locally with private key)
-- **Client-side:** uses `loop.provider.submitTransaction()` (delegates signing to Loop Wallet via WebSocket)
+- **Loop:** pass the Loop SDK instance directly, or use `createLoopWalletAdapter(loop)`.
+- **Console:** pass the Console wallet instance directly, or use `createConsoleWalletAdapter(consoleWallet)`. The adapter uses `getPrimaryAccount()` and `getContracts()` for reads, and submits the same Temple Daml command object that Loop receives through Console's `prepareExecuteAndWait()` or `prepareExecute()` methods when available.
 
 ```javascript
 import { initialize } from "@temple-digital-group/temple-canton-js";
 
+// `wallet` is a supported wallet instance (e.g. a Loop SDK or Console wallet instance).
 initialize({
 	API_KEY: "your-api-key",
 	NETWORK: "mainnet",
-	WALLET_ADAPTER: loop, // Pass the Loop SDK instance
+	WALLET_ADAPTER: wallet,
 });
 ```
 
@@ -34,14 +35,14 @@ You can also set or change the wallet adapter after init:
 ```javascript
 import { setWalletAdapter } from "@temple-digital-group/temple-canton-js";
 
-setWalletAdapter(loop);
+setWalletAdapter(wallet);
 ```
 
-| Key              | Required | Description                                                     |
-| ---------------- | -------- | --------------------------------------------------------------- |
-| `API_KEY`        | Yes      | Temple REST API key                                             |
-| `NETWORK`        | Yes      | `mainnet` or `testnet`                                          |
-| `WALLET_ADAPTER` | Yes      | Loop SDK instance — auto-detects server/client mode for signing |
+| Key              | Required | Description                                       |
+| ---------------- | -------- | ------------------------------------------------- |
+| `API_KEY`        | Yes      | Temple REST API key                               |
+| `NETWORK`        | Yes      | `mainnet` or `testnet`                            |
+| `WALLET_ADAPTER` | Yes      | Supported wallet instance or normalized adapter   |
 
 ## Supported Instruments
 
@@ -344,14 +345,14 @@ const unsubOrder = ws.onUserEvent("user_order", (data) => { ... });
 
 ## API Reference
 
-> Functions marked with **W** support Loop Wallet via the wallet adapter.
+> Functions marked with **W** support configured wallets via the wallet adapter.
 
 ### Configuration
 
 | Function                    | Description                                                                   |
 | --------------------------- | ----------------------------------------------------------------------------- |
 | `initialize(config)`        | Initialize the SDK, set config, and optionally authenticate with the REST API |
-| `setWalletAdapter(adapter)` | Set or update the Loop SDK instance for all wallet-aware functions            |
+| `setWalletAdapter(adapter)` | Set or update the wallet adapter for all wallet-aware functions               |
 
 ### Instrument Catalog
 

package/dist/canton/deposits.js

@@ -120,7 +120,7 @@ export async function prepareDepositHoldings(amount, symbol) {
     if (!provider && !config.VALIDATOR_SCAN_API_URL) {
         return { error: "prepareDepositHoldings: wallet provider is required to prepare holdings. Connect a wallet adapter." };
     }
-    const party = getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+    const party = (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
     if (!party) {
         return { error: "prepareDepositHoldings: party ID is required. Connect a wallet adapter or configure VALIDATOR_USER_PARTY_ID." };
     }
@@ -212,7 +212,7 @@ export async function deposit(amount, symbol) {
     if (!getWalletAdapter()) {
         return { error: "deposit: wallet adapter is required. Call setWalletAdapter() first." };
     }
-    const party = getAdapterPartyId();
+    const party = await getAdapterPartyId();
     if (!party) {
         return { error: "deposit: could not resolve party ID from wallet adapter." };
     }

package/dist/canton/wallet/adapter.d.ts

@@ -1,7 +1,7 @@
 /**
  * Universal Wallet Adapter contract.
  *
- * Every wallet (Loop, and future providers such as Console or BitGo) is
+ * Every wallet provider is
  * represented as a *normalized adapter* implementing the capability interface
  * defined here. The rest of the SDK never talks to a wallet/provider SDK
  * directly — it goes through the wallet service (./service.js), which dispatches
@@ -25,12 +25,12 @@
  */
 /** A normalized wallet adapter produced by {@link defineWalletAdapter}. */
 export interface WalletAdapter {
-    /** Provider id, e.g. "loop". */
+    /** Provider id, e.g. "loop" or "console". */
     readonly id: string;
     /** True for server-side adapters that sign/submit locally. */
     readonly isServer: boolean;
-    /** Resolve the wallet's primary party id. */
-    getPartyId(): string | null;
+    /** Resolve the wallet's primary party id. May resolve asynchronously. */
+    getPartyId(): Promise<string | null>;
     /** Read active contracts matching `args` via the wallet. */
     getActiveContracts(args: unknown): Promise<unknown>;
     /** Sign and submit a ledger command via the wallet. */
@@ -52,7 +52,7 @@ export interface WalletAdapter {
 export interface WalletAdapterDefinition {
     id?: string;
     isServer?: boolean;
-    getPartyId(): string | null;
+    getPartyId(): string | null | Promise<string | null>;
     getActiveContracts(args: unknown): Promise<unknown> | unknown;
     submitCommand(command: unknown): Promise<unknown> | unknown;
     payDueGasIfAny?(): Promise<void> | void;

package/dist/canton/wallet/adapter.js

@@ -1,7 +1,7 @@
 /**
  * Universal Wallet Adapter contract.
  *
- * Every wallet (Loop, and future providers such as Console or BitGo) is
+ * Every wallet provider is
  * represented as a *normalized adapter* implementing the capability interface
  * defined here. The rest of the SDK never talks to a wallet/provider SDK
  * directly — it goes through the wallet service (./service.js), which dispatches

package/dist/canton/wallet/console.d.ts

@@ -0,0 +1,15 @@
+import { type WalletAdapter } from "./adapter.js";
+type ConsoleNetworkVariant = "CANTON_NETWORK_DEV" | "CANTON_NETWORK_TEST" | "CANTON_NETWORK";
+export interface ConsoleWalletAdapterOptions {
+    /** Console network id. Defaults from config.NETWORK when omitted. */
+    network?: ConsoleNetworkVariant | "localhost" | "testnet" | "mainnet" | string;
+    /** Optional party id seed for SDK call sites that need a synchronous party. */
+    partyId?: string;
+    /** Optional explicit read parties. Defaults to the active Console account party. */
+    parties?: string[];
+    /** Use prepareExecuteAndWait when available. Defaults to true. */
+    waitForExecution?: boolean;
+}
+export declare function isConsoleWalletLike(value: unknown): boolean;
+export declare function createConsoleWalletAdapter(consoleWallet: unknown, options?: ConsoleWalletAdapterOptions): WalletAdapter;
+export {};

package/dist/canton/wallet/console.js

@@ -0,0 +1,232 @@
+import config from "../../../src/config/index.js";
+import { defineWalletAdapter } from "./adapter.js";
+function hasConsoleSubmitCapability(value) {
+    return typeof value.prepareExecute === "function" || typeof value.prepareExecuteAndWait === "function";
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPromiseLike(value) {
+    return isRecord(value) && typeof value.then === "function";
+}
+function asStringArray(value) {
+    if (Array.isArray(value))
+        return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+    if (typeof value === "string" && value.length > 0)
+        return [value];
+    return [];
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+function firstRecord(...values) {
+    for (const value of values) {
+        if (isRecord(value))
+            return value;
+    }
+    return undefined;
+}
+function resolveConsoleWallet(input) {
+    const candidate = isRecord(input) && isRecord(input.consoleWallet) ? input.consoleWallet : input;
+    if (!isRecord(candidate)) {
+        throw new Error("[Temple SDK] createConsoleWalletAdapter requires a Console wallet SDK instance.");
+    }
+    if (typeof candidate.getPrimaryAccount !== "function" || typeof candidate.getContracts !== "function") {
+        throw new Error("[Temple SDK] Console wallet SDK must expose getPrimaryAccount() and getContracts().");
+    }
+    if (!hasConsoleSubmitCapability(candidate)) {
+        throw new Error("[Temple SDK] Console wallet SDK must expose prepareExecute() or prepareExecuteAndWait().");
+    }
+    return candidate;
+}
+export function isConsoleWalletLike(value) {
+    const candidate = isRecord(value) && isRecord(value.consoleWallet) ? value.consoleWallet : value;
+    return isRecord(candidate) && typeof candidate.getPrimaryAccount === "function" && typeof candidate.getContracts === "function" && hasConsoleSubmitCapability(candidate);
+}
+function resolveNetwork(network) {
+    const configured = String(network || config.NETWORK || "").toLowerCase();
+    switch (configured) {
+        case "localhost":
+        case "local":
+        case "dev":
+        case "devnet":
+            return "CANTON_NETWORK_DEV";
+        case "testnet":
+        case "test":
+            return "CANTON_NETWORK_TEST";
+        case "mainnet":
+        case "main":
+            return "CANTON_NETWORK";
+        default:
+            return network || "CANTON_NETWORK";
+    }
+}
+function extractPartyId(account) {
+    return typeof account?.partyId === "string" && account.partyId ? account.partyId : null;
+}
+function extractTemplateIds(args) {
+    if (!isRecord(args))
+        return [];
+    const direct = [...asStringArray(args.templateIds), ...asStringArray(args.templateId)];
+    if (direct.length > 0)
+        return direct;
+    const filter = firstRecord(args.filter);
+    const filtersByParty = firstRecord(filter?.filtersByParty);
+    const templateIds = [];
+    for (const partyFilter of Object.values(filtersByParty || {})) {
+        const cumulative = firstRecord(partyFilter)?.cumulative;
+        if (!Array.isArray(cumulative))
+            continue;
+        for (const entry of cumulative) {
+            const identifierFilter = firstRecord(entry)?.identifierFilter;
+            const templateFilter = firstRecord(firstRecord(identifierFilter)?.["TemplateFilter"])?.value;
+            templateIds.push(...asStringArray(firstRecord(templateFilter)?.templateId));
+        }
+    }
+    return templateIds;
+}
+function extractParties(args, fallbackParty, optionParties) {
+    if (optionParties?.length)
+        return optionParties;
+    if (isRecord(args)) {
+        const direct = [...asStringArray(args.parties), ...asStringArray(args.party)];
+        if (direct.length > 0)
+            return direct;
+        const filtersByParty = firstRecord(firstRecord(args.filter)?.filtersByParty);
+        const filteredParties = Object.keys(filtersByParty || {});
+        if (filteredParties.length > 0)
+            return filteredParties;
+    }
+    return fallbackParty ? [fallbackParty] : [];
+}
+function unwrapContractItems(response) {
+    if (Array.isArray(response))
+        return response;
+    if (!isRecord(response))
+        return [];
+    for (const key of ["items", "activeContracts", "contracts", "result"]) {
+        const value = response[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function normalizeContractItem(item) {
+    if (!isRecord(item))
+        return null;
+    const contractEntry = firstRecord(item.contractEntry) || item;
+    const jsActive = firstRecord(contractEntry.JsActiveContract, contractEntry.jsActiveContract, contractEntry.activeContract) || contractEntry;
+    const createdEvent = firstRecord(jsActive.createdEvent, item.createdEvent, item.contract, jsActive) || {};
+    const createArgument = firstRecord(createdEvent.createArgument, createdEvent.create_argument, createdEvent.payload, item.payload) || {};
+    const contractId = firstString(createdEvent.contractId, createdEvent.contract_id, item.contractId, item.contract_id);
+    const templateId = firstString(createdEvent.templateId, createdEvent.template_id, jsActive.templateId, item.templateId, item.template_id);
+    const createdEventBlob = firstString(createdEvent.createdEventBlob, createdEvent.created_event_blob, createdEvent.eventBlob, item.createdEventBlob, item.created_event_blob, item.eventBlob);
+    const synchronizerId = firstString(jsActive.synchronizerId, jsActive.synchronizer_id, item.synchronizerId, item.synchronizer_id, item.domainId, item.domain_id);
+    if (!contractId && !templateId && !createdEventBlob)
+        return null;
+    return {
+        contractEntry: {
+            JsActiveContract: {
+                ...jsActive,
+                createdEvent: {
+                    ...createdEvent,
+                    contractId,
+                    templateId,
+                    createArgument,
+                    createdEventBlob,
+                },
+                synchronizerId,
+                templateId,
+            },
+        },
+    };
+}
+function normalizeContractsResponse(response) {
+    return unwrapContractItems(response)
+        .map(normalizeContractItem)
+        .filter((entry) => entry !== null);
+}
+function extractErrorDetail(error) {
+    if (!isRecord(error))
+        return String(error);
+    const response = isRecord(error.response) ? error.response : undefined;
+    const data = response && response.data !== undefined ? response.data : undefined;
+    if (typeof data === "string")
+        return data;
+    if (isRecord(data))
+        return JSON.stringify(data);
+    if (typeof error.message === "string")
+        return error.message;
+    return String(error);
+}
+function wrapConsoleSubmitError(error) {
+    const detail = extractErrorDetail(error);
+    return new Error(`[Temple SDK] Console wallet submit failed: ${detail}.`);
+}
+function normalizeLedgerCommand(command) {
+    if (!isRecord(command) || !Array.isArray(command.commands)) {
+        throw new Error("[Temple SDK] Console wallet submitCommand() expects a ledger command with a commands array.");
+    }
+    return command;
+}
+export function createConsoleWalletAdapter(consoleWallet, options = {}) {
+    const wallet = resolveConsoleWallet(consoleWallet);
+    let cachedPartyId = options.partyId || null;
+    let pendingPartyId = null;
+    const loadPartyId = async () => {
+        const account = await wallet.getPrimaryAccount();
+        cachedPartyId = extractPartyId(account);
+        pendingPartyId = null;
+        return cachedPartyId;
+    };
+    const ensurePartyId = async () => {
+        if (cachedPartyId)
+            return cachedPartyId;
+        if (!pendingPartyId)
+            pendingPartyId = loadPartyId();
+        return pendingPartyId;
+    };
+    return defineWalletAdapter({
+        id: "console",
+        isServer: false,
+        getRawProvider: () => wallet,
+        getPartyId: ensurePartyId,
+        getActiveContracts: async (args) => {
+            const partyId = await ensurePartyId();
+            const templateIds = extractTemplateIds(args);
+            const parties = extractParties(args, partyId, options.parties);
+            if (templateIds.length === 0) {
+                throw new Error("[Temple SDK] Console wallet getActiveContracts() requires at least one templateId.");
+            }
+            if (parties.length === 0) {
+                throw new Error("[Temple SDK] Console wallet getActiveContracts() requires a party id from getPrimaryAccount() or adapter options.");
+            }
+            const response = await wallet.getContracts({
+                network: resolveNetwork(options.network),
+                parties,
+                templateIds,
+            });
+            return normalizeContractsResponse(response);
+        },
+        submitCommand: async (command) => {
+            // resolveConsoleWallet() guarantees at least one prepare method exists.
+            const prepareRequest = normalizeLedgerCommand(command);
+            const useWait = typeof wallet.prepareExecuteAndWait === "function" &&
+                (options.waitForExecution !== false || typeof wallet.prepareExecute !== "function");
+            try {
+                return await (useWait ? wallet.prepareExecuteAndWait(prepareRequest) : wallet.prepareExecute(prepareRequest));
+            }
+            catch (error) {
+                throw wrapConsoleSubmitError(error);
+            }
+        },
+        disconnect: async () => {
+            if (typeof wallet.disconnect === "function")
+                await wallet.disconnect();
+        },
+    });
+}

package/dist/canton/wallet/loop.d.ts

@@ -15,6 +15,7 @@
  * has a null connection.ticketId and connection.ws.
  */
 import { type WalletAdapter } from "./adapter.js";
+export declare function isLoopWalletLike(value: unknown): boolean;
 /**
  * Create a universal wallet adapter backed by a Loop SDK instance.
  */

package/dist/canton/wallet/loop.js

@@ -15,6 +15,19 @@
  * has a null connection.ticketId and connection.ws.
  */
 import { defineWalletAdapter } from "./adapter.js";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export function isLoopWalletLike(value) {
+    if (!isRecord(value))
+        return false;
+    const provider = isRecord(value.provider) ? value.provider : value;
+    return (typeof provider.getActiveContracts === "function" &&
+        (typeof value.executeTransaction === "function" ||
+            typeof provider.submitTransaction === "function" ||
+            isRecord(value.session) ||
+            typeof provider.party_id === "string"));
+}
 /**
  * Detect whether a Loop instance is server-side.
  * Loop-specific: server-side has null connection.ticketId and connection.ws.
@@ -33,6 +46,9 @@ export function createLoopWalletAdapter(loop) {
     if (!loop || typeof loop !== "object") {
         throw new Error("[Temple SDK] createLoopWalletAdapter requires a Loop wallet instance.");
     }
+    if (!isLoopWalletLike(loop)) {
+        throw new Error("[Temple SDK] createLoopWalletAdapter received an unsupported Loop wallet instance.");
+    }
     const sdk = loop;
     const isServer = detectServerSide(sdk);
     // The provider sub-object handles reads (getActiveContracts) and client-side

package/dist/canton/wallet/registry.d.ts

@@ -0,0 +1,2 @@
+import { type WalletAdapter } from "./adapter.js";
+export declare function normalizeWalletAdapter(adapter: unknown): WalletAdapter;

package/dist/canton/wallet/registry.js

@@ -0,0 +1,16 @@
+import { isWalletAdapter } from "./adapter.js";
+import { createConsoleWalletAdapter, isConsoleWalletLike } from "./console.js";
+import { createLoopWalletAdapter, isLoopWalletLike } from "./loop.js";
+const BUILT_IN_FACTORIES = [
+    { id: "console", canWrap: isConsoleWalletLike, wrap: (value) => createConsoleWalletAdapter(value) },
+    { id: "loop", canWrap: isLoopWalletLike, wrap: createLoopWalletAdapter },
+];
+export function normalizeWalletAdapter(adapter) {
+    if (isWalletAdapter(adapter))
+        return adapter;
+    for (const factory of BUILT_IN_FACTORIES) {
+        if (factory.canWrap(adapter))
+            return factory.wrap(adapter);
+    }
+    throw new Error("[Temple SDK] Unsupported wallet adapter. Pass a normalized adapter from createLoopWalletAdapter(), createConsoleWalletAdapter(), or defineWalletAdapter().");
+}

package/dist/canton/wallet/service.d.ts

@@ -21,7 +21,7 @@ export declare function getActiveAdapter(): WalletAdapter | null;
 /** True when a wallet adapter is configured. */
 export declare function hasActiveAdapter(): boolean;
 /** Resolve the active wallet's party id. Throws when no adapter is configured. */
-export declare function getPartyId(): string | null;
+export declare function getPartyId(): Promise<string | null>;
 /** Sign and submit a ledger command. Throws when no adapter is configured. */
 export declare function submitCommand(command: unknown): Promise<unknown>;
 /**

package/dist/canton/walletAdapter.d.ts

@@ -4,7 +4,7 @@
  * Backward-compatible public surface for wallet interactions. The real wallet
  * architecture lives in ./wallet/ — a universal adapter contract (adapter.ts),
  * a service registry that dispatches capability calls (service.ts), and one
- * factory per wallet (loop.ts, and future providers). This module is a thin
+ * factory per wallet provider. This module is a thin
  * facade over that service so existing imports keep working unchanged.
  *
  * Adding a new wallet does not touch this file: write a create<Name>WalletAdapter()
@@ -12,13 +12,15 @@
  */
 import type { WalletAdapter } from "./wallet/adapter.js";
 export { createLoopWalletAdapter } from "./wallet/loop.js";
+export { createConsoleWalletAdapter } from "./wallet/console.js";
 export { defineWalletAdapter, isWalletAdapter } from "./wallet/adapter.js";
 export type { WalletAdapter, WalletAdapterDefinition } from "./wallet/adapter.js";
+export type { ConsoleWalletAdapterOptions } from "./wallet/console.js";
 /**
  * Set the active wallet adapter.
  *
  * Accepts either a normalized adapter (from a create*WalletAdapter() factory) or
- * a raw Loop SDK instance, which is auto-wrapped for backward compatibility.
+ * a raw wallet instance recognized by a built-in wallet factory.
  * Pass a falsy value to clear the adapter.
  */
 export declare function setWalletAdapter(adapter: unknown): void;
@@ -38,7 +40,7 @@ export declare function isServerMode(): boolean;
 /**
  * Get the party ID from the active wallet adapter, or null when none is set.
  */
-export declare function getAdapterPartyId(): string | null;
+export declare function getAdapterPartyId(): Promise<string | null>;
 /**
  * Pay any outstanding network gas before submitting a transaction or reading
  * balances. Safe no-op when no adapter is configured or the wallet handles gas

package/dist/canton/walletAdapter.js

@@ -4,23 +4,23 @@
  * Backward-compatible public surface for wallet interactions. The real wallet
  * architecture lives in ./wallet/ — a universal adapter contract (adapter.ts),
  * a service registry that dispatches capability calls (service.ts), and one
- * factory per wallet (loop.ts, and future providers). This module is a thin
+ * factory per wallet provider. This module is a thin
  * facade over that service so existing imports keep working unchanged.
  *
  * Adding a new wallet does not touch this file: write a create<Name>WalletAdapter()
  * factory and pass its result to setWalletAdapter().
  */
 import { setActiveAdapter, getActiveAdapter, submitCommand as serviceSubmitCommand, payDueGasIfAny as servicePayDueGasIfAny, } from "./wallet/service.js";
-import { isWalletAdapter } from "./wallet/adapter.js";
-import { createLoopWalletAdapter } from "./wallet/loop.js";
+import { normalizeWalletAdapter } from "./wallet/registry.js";
 // Re-export the adapter toolkit so consumers can build/register custom wallets.
 export { createLoopWalletAdapter } from "./wallet/loop.js";
+export { createConsoleWalletAdapter } from "./wallet/console.js";
 export { defineWalletAdapter, isWalletAdapter } from "./wallet/adapter.js";
 /**
  * Set the active wallet adapter.
  *
  * Accepts either a normalized adapter (from a create*WalletAdapter() factory) or
- * a raw Loop SDK instance, which is auto-wrapped for backward compatibility.
+ * a raw wallet instance recognized by a built-in wallet factory.
  * Pass a falsy value to clear the adapter.
  */
 export function setWalletAdapter(adapter) {
@@ -28,8 +28,7 @@ export function setWalletAdapter(adapter) {
         setActiveAdapter(null);
         return;
     }
-    const normalized = isWalletAdapter(adapter) ? adapter : createLoopWalletAdapter(adapter);
-    setActiveAdapter(normalized);
+    setActiveAdapter(normalizeWalletAdapter(adapter));
 }
 /**
  * Get the active (normalized) wallet adapter, or null when none is set.
@@ -57,7 +56,7 @@ export function isServerMode() {
 /**
  * Get the party ID from the active wallet adapter, or null when none is set.
  */
-export function getAdapterPartyId() {
+export async function getAdapterPartyId() {
     const adapter = getActiveAdapter();
     return adapter ? adapter.getPartyId() : null;
 }

package/dist/canton/withdrawals.js

@@ -20,7 +20,7 @@ const CC_FEE_RESERVE = 10;
 export async function finalizeWithdrawFunds(opts, returnCommand = false) {
     const { allocationId, sender: senderOpt, assetId: rawAssetId, disclosures, userId } = opts;
     const assetId = normalizeAssetId(rawAssetId);
-    const sender = getAdapterPartyId() ?? senderOpt ?? config.VALIDATOR_USER_PARTY_ID;
+    const sender = (await getAdapterPartyId()) ?? senderOpt ?? config.VALIDATOR_USER_PARTY_ID;
     if (!allocationId || !sender || !assetId) {
         const msg = "finalizeWithdrawFunds: allocationId, sender, and assetId are required";
         console.error(msg);
@@ -267,7 +267,7 @@ export async function finalizeWithdrawFunds(opts, returnCommand = false) {
 export async function withdrawFunds(opts, returnCommand = false) {
     const { amount, pollIntervalMs = 2000, maxPollAttempts = 30 } = opts || {};
     const asset_id = normalizeAssetId(opts?.asset_id);
-    const sender = getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+    const sender = (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
     if (!sender) {
         const msg = "withdrawFunds: sender party is required. Connect a wallet adapter or configure VALIDATOR_USER_PARTY_ID.";
         console.error(msg);
@@ -343,7 +343,7 @@ export async function withdrawFunds(opts, returnCommand = false) {
  * which archives the delegation and revokes the operator's authority.
  */
 export async function withdrawDelegation(delegationId = null, user = null, returnCommand = false) {
-    let resolvedUser = user ?? getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+    let resolvedUser = user ?? (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
     let resolvedDelegationId = delegationId;
     // If no delegationId passed, fetch it from the API
     if (!resolvedDelegationId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temple-digital-group/temple-canton-js",
-  "version": "2.0.6",
+  "version": "2.1.0-beta.0",
   "description": "JavaScript library for interacting with Temple Canton blockchain",
   "type": "module",
   "main": "index.js",

package/src/api/config.d.ts

@@ -17,4 +17,11 @@ declare module "../../src/config/index.js" {
 	export function setWalletAdapter(adapter: unknown): void;
 	export function getWalletAdapter(): unknown;
 	export function getAdapterProvider(): unknown;
+	export interface ConsoleWalletAdapterOptions {
+		network?: string;
+		partyId?: string;
+		parties?: string[];
+		waitForExecution?: boolean;
+	}
+	export function createConsoleWalletAdapter(consoleWallet: unknown, options?: ConsoleWalletAdapterOptions): unknown;
 }

package/src/canton/deposits.ts

@@ -198,7 +198,7 @@ export async function prepareDepositHoldings(
 		return { error: "prepareDepositHoldings: wallet provider is required to prepare holdings. Connect a wallet adapter." };
 	}
 
-	const party = getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+	const party = (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
 	if (!party) {
 		return { error: "prepareDepositHoldings: party ID is required. Connect a wallet adapter or configure VALIDATOR_USER_PARTY_ID." };
 	}
@@ -306,7 +306,7 @@ export async function deposit(
 		return { error: "deposit: wallet adapter is required. Call setWalletAdapter() first." };
 	}
 
-	const party = getAdapterPartyId();
+	const party = await getAdapterPartyId();
 	if (!party) {
 		return { error: "deposit: could not resolve party ID from wallet adapter." };
 	}

package/src/canton/index.js

@@ -1438,7 +1438,7 @@ export async function getCandidateMiningRoundContract(dso, returnCommand = false
  * Get Amulet holdings for a party from the ledger or a provider.
  * @param {string} party - The party ID
  * @param {boolean} [returnCommand=false] - If true, returns the raw command/endpoint instead of executing
- * @param {Object|null} [provider=null] - Optional external provider (e.g., Loop Wallet) to use instead of ledger API
+ * @param {Object|null} [provider=null] - Optional wallet provider to use instead of ledger API
  * @returns {Promise<Object|null>} Holdings data, or null on failure
  */
 export async function getAmuletHoldingsForParty(party, returnCommand = false, provider = null) {
@@ -1948,7 +1948,7 @@ export async function getCandidateHoldingForOrderCreation(party, isAmulet, requi
  * returns the command for the wallet to sign instead of submitting directly.
  * @param {string} party - The party ID
  * @param {boolean} [returnCommand=false] - If true, returns the raw command/endpoint instead of executing
- * @param {Object|null} [provider=null] - Optional external provider (e.g., Loop Wallet) to use instead of ledger API
+ * @param {Object|null} [provider=null] - Optional wallet provider to use instead of ledger API
  * @param {number|null} [maxUtxos=null] - Maximum number of UTXOs to merge (picks smallest first). Null = merge all.
  * @param {Array} [amuletDisclosures=[]] - Pre-fetched Amulet disclosures (required when using a provider). Must contain AmuletRules, OpenMiningRound, and ExternalPartyAmuletRules.
  * @returns {Promise<Object|null>} Merge result data, or null on failure
@@ -1961,7 +1961,7 @@ export async function mergeAmuletHoldingsForParty(party, returnCommand = false,
 			return { error: "amuletDisclosures are required when using a provider for Amulet merge" };
 		}
 		returnCommand = true;
-		// Wallet providers (e.g., Loop) have a ~100 contract limit per transaction.
+		// Wallet providers commonly have a ~100 contract limit per transaction.
 		if (!maxUtxos) {
 			maxUtxos = 100;
 		}
@@ -2171,7 +2171,7 @@ export async function mergeAmuletHoldingsForParty(party, returnCommand = false,
  * @param {string} party - The party ID
  * @param {string} utilityAsset - The utility asset ID (e.g., "USDCx", "CBTC")
  * @param {boolean} [returnCommand=false] - If true, returns the raw command/endpoint instead of executing. Forced to true when provider is set.
- * @param {Object} [provider=null] - Wallet provider (e.g., Loop Wallet) with getActiveContracts(). When set, skips ledger API calls and returns the command for the wallet to sign.
+ * @param {Object} [provider=null] - Wallet provider with getActiveContracts(). When set, skips ledger API calls and returns the command for the wallet to sign.
  * @param {number} [maxUtxos=null] - Maximum number of UTXOs to merge. When set, picks the smallest holdings first.
  * @returns {Promise<Object|null>} Merge result data, or {command, endpoint} when returnCommand is true, or null on failure
  */
@@ -2180,7 +2180,7 @@ export async function mergeUtilityHoldingsForParty(party, utilityAsset, returnCo
 	provider = resolveProvider(provider);
 	if (provider) {
 		returnCommand = true;
-		// Wallet providers (e.g., Loop) have a ~100 contract limit per transaction.
+		// Wallet providers commonly have a ~100 contract limit per transaction.
 		// Default to 100 when no explicit maxUtxos is set.
 		if (!maxUtxos) {
 			maxUtxos = 100;
@@ -2656,7 +2656,7 @@ export { finalizeWithdrawFunds, withdrawFunds, withdrawDelegation } from "../../
 export async function buildAllocationWithdrawCommand(opts) {
 	const { disclosures, userId } = opts || {};
 	const assetId = normalizeAssetId(opts.assetId);
-	const sender = getAdapterPartyId() || opts.sender || config.VALIDATOR_USER_PARTY_ID;
+	const sender = (await getAdapterPartyId()) || opts.sender || config.VALIDATOR_USER_PARTY_ID;
 
 	if (!opts.allocationCids || !sender || !assetId) {
 		return { error: "buildAllocationWithdrawCommand: allocationCids, sender, and assetId are required" };
@@ -2848,7 +2848,7 @@ export async function buildAllocationWithdrawCommand(opts) {
  * @returns {Promise<Object>} Ledger API response, or { error } on failure.
  */
 export async function onboardUser(user = {}, returnCommand = false) {
-	user.partyId = user.partyId ?? getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+	user.partyId = user.partyId ?? (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
 	user.userId = user.userId ?? getUserId() ?? config.AUTH0_USER_ID ?? "temple";
 	if (!user.partyId) {
 		const msg = "onboardUser: user party is required. Pass it directly, set WALLET_ADAPTER, or configure VALIDATOR_USER_PARTY_ID.";
@@ -3031,7 +3031,7 @@ export async function getUserBalances(party = null, provider = null) {
 		console.error(msg);
 		return { error: msg };
 	}
-	party = party ?? getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+	party = party ?? (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
 	if (!party) {
 		return { error: "Party ID is required. Pass it directly, connect a wallet adapter, or configure VALIDATOR_USER_PARTY_ID." };
 	}

package/src/canton/wallet/adapter.ts

@@ -1,7 +1,7 @@
 /**
  * Universal Wallet Adapter contract.
  *
- * Every wallet (Loop, and future providers such as Console or BitGo) is
+ * Every wallet provider is
  * represented as a *normalized adapter* implementing the capability interface
  * defined here. The rest of the SDK never talks to a wallet/provider SDK
  * directly — it goes through the wallet service (./service.js), which dispatches
@@ -26,14 +26,14 @@
 
 /** A normalized wallet adapter produced by {@link defineWalletAdapter}. */
 export interface WalletAdapter {
-	/** Provider id, e.g. "loop". */
+	/** Provider id, e.g. "loop" or "console". */
 	readonly id: string;
 	/** True for server-side adapters that sign/submit locally. */
 	readonly isServer: boolean;
 
 	// ── Required capabilities ──
-	/** Resolve the wallet's primary party id. */
-	getPartyId(): string | null;
+	/** Resolve the wallet's primary party id. May resolve asynchronously. */
+	getPartyId(): Promise<string | null>;
 	/** Read active contracts matching `args` via the wallet. */
 	getActiveContracts(args: unknown): Promise<unknown>;
 	/** Sign and submit a ledger command via the wallet. */
@@ -59,7 +59,7 @@ export interface WalletAdapter {
 export interface WalletAdapterDefinition {
 	id?: string;
 	isServer?: boolean;
-	getPartyId(): string | null;
+	getPartyId(): string | null | Promise<string | null>;
 	getActiveContracts(args: unknown): Promise<unknown> | unknown;
 	submitCommand(command: unknown): Promise<unknown> | unknown;
 	payDueGasIfAny?(): Promise<void> | void;

package/src/canton/wallet/console.ts

@@ -0,0 +1,281 @@
+import config from "../../../src/config/index.js";
+import { defineWalletAdapter, type WalletAdapter } from "./adapter.js";
+
+type ConsoleNetworkVariant = "CANTON_NETWORK_DEV" | "CANTON_NETWORK_TEST" | "CANTON_NETWORK";
+
+export interface ConsoleWalletAdapterOptions {
+	/** Console network id. Defaults from config.NETWORK when omitted. */
+	network?: ConsoleNetworkVariant | "localhost" | "testnet" | "mainnet" | string;
+	/** Optional party id seed for SDK call sites that need a synchronous party. */
+	partyId?: string;
+	/** Optional explicit read parties. Defaults to the active Console account party. */
+	parties?: string[];
+	/** Use prepareExecuteAndWait when available. Defaults to true. */
+	waitForExecution?: boolean;
+}
+
+interface ConsoleWalletAccount {
+	partyId?: string | null;
+	networkId?: string | null;
+	[key: string]: unknown;
+}
+
+interface ConsoleContractsRequest {
+	network: ConsoleNetworkVariant | string;
+	parties: string[];
+	templateIds: string[];
+}
+
+interface ConsoleWalletLike {
+	getPrimaryAccount: () => Promise<ConsoleWalletAccount | undefined> | ConsoleWalletAccount | undefined;
+	getContracts: (data: ConsoleContractsRequest) => Promise<unknown> | unknown;
+	prepareExecute?: (data: ConsoleExecuteRequest) => Promise<unknown> | unknown;
+	prepareExecuteAndWait?: (data: ConsoleExecuteRequest) => Promise<unknown> | unknown;
+	disconnect?: () => Promise<void> | void;
+}
+
+interface ConsoleExecuteRequest {
+	actAs?: string[];
+	commandId?: string;
+	commands: unknown[];
+	disclosedContracts?: unknown[];
+	packageIdSelectionPreference?: string[];
+	readAs?: string[];
+	synchronizerId?: string;
+}
+
+function hasConsoleSubmitCapability(value: Record<string, unknown>): boolean {
+	return typeof value.prepareExecute === "function" || typeof value.prepareExecuteAndWait === "function";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isPromiseLike<T>(value: unknown): value is PromiseLike<T> {
+	return isRecord(value) && typeof value.then === "function";
+}
+
+function asStringArray(value: unknown): string[] {
+	if (Array.isArray(value)) return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+	if (typeof value === "string" && value.length > 0) return [value];
+	return [];
+}
+
+function firstString(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function firstRecord(...values: unknown[]): Record<string, unknown> | undefined {
+	for (const value of values) {
+		if (isRecord(value)) return value;
+	}
+	return undefined;
+}
+
+function resolveConsoleWallet(input: unknown): ConsoleWalletLike {
+	const candidate = isRecord(input) && isRecord(input.consoleWallet) ? input.consoleWallet : input;
+	if (!isRecord(candidate)) {
+		throw new Error("[Temple SDK] createConsoleWalletAdapter requires a Console wallet SDK instance.");
+	}
+	if (typeof candidate.getPrimaryAccount !== "function" || typeof candidate.getContracts !== "function") {
+		throw new Error("[Temple SDK] Console wallet SDK must expose getPrimaryAccount() and getContracts().");
+	}
+	if (!hasConsoleSubmitCapability(candidate)) {
+		throw new Error("[Temple SDK] Console wallet SDK must expose prepareExecute() or prepareExecuteAndWait().");
+	}
+	return candidate as unknown as ConsoleWalletLike;
+}
+
+export function isConsoleWalletLike(value: unknown): boolean {
+	const candidate = isRecord(value) && isRecord(value.consoleWallet) ? value.consoleWallet : value;
+	return isRecord(candidate) && typeof candidate.getPrimaryAccount === "function" && typeof candidate.getContracts === "function" && hasConsoleSubmitCapability(candidate);
+}
+
+function resolveNetwork(network: ConsoleWalletAdapterOptions["network"]): ConsoleNetworkVariant | string {
+	const configured = String(network || config.NETWORK || "").toLowerCase();
+	switch (configured) {
+		case "localhost":
+		case "local":
+		case "dev":
+		case "devnet":
+			return "CANTON_NETWORK_DEV";
+		case "testnet":
+		case "test":
+			return "CANTON_NETWORK_TEST";
+		case "mainnet":
+		case "main":
+			return "CANTON_NETWORK";
+		default:
+			return network || "CANTON_NETWORK";
+	}
+}
+
+function extractPartyId(account: ConsoleWalletAccount | undefined): string | null {
+	return typeof account?.partyId === "string" && account.partyId ? account.partyId : null;
+}
+
+function extractTemplateIds(args: unknown): string[] {
+	if (!isRecord(args)) return [];
+	const direct = [...asStringArray(args.templateIds), ...asStringArray(args.templateId)];
+	if (direct.length > 0) return direct;
+
+	const filter = firstRecord(args.filter);
+	const filtersByParty = firstRecord(filter?.filtersByParty);
+	const templateIds: string[] = [];
+	for (const partyFilter of Object.values(filtersByParty || {})) {
+		const cumulative = firstRecord(partyFilter)?.cumulative;
+		if (!Array.isArray(cumulative)) continue;
+		for (const entry of cumulative) {
+			const identifierFilter = firstRecord(entry)?.identifierFilter;
+			const templateFilter = firstRecord(firstRecord(identifierFilter)?.["TemplateFilter"])?.value;
+			templateIds.push(...asStringArray(firstRecord(templateFilter)?.templateId));
+		}
+	}
+	return templateIds;
+}
+
+function extractParties(args: unknown, fallbackParty: string | null, optionParties: string[] | undefined): string[] {
+	if (optionParties?.length) return optionParties;
+	if (isRecord(args)) {
+		const direct = [...asStringArray(args.parties), ...asStringArray(args.party)];
+		if (direct.length > 0) return direct;
+		const filtersByParty = firstRecord(firstRecord(args.filter)?.filtersByParty);
+		const filteredParties = Object.keys(filtersByParty || {});
+		if (filteredParties.length > 0) return filteredParties;
+	}
+	return fallbackParty ? [fallbackParty] : [];
+}
+
+function unwrapContractItems(response: unknown): unknown[] {
+	if (Array.isArray(response)) return response;
+	if (!isRecord(response)) return [];
+	for (const key of ["items", "activeContracts", "contracts", "result"]) {
+		const value = response[key];
+		if (Array.isArray(value)) return value;
+	}
+	return [];
+}
+
+function normalizeContractItem(item: unknown): unknown | null {
+	if (!isRecord(item)) return null;
+	const contractEntry = firstRecord(item.contractEntry) || item;
+	const jsActive = firstRecord(contractEntry.JsActiveContract, contractEntry.jsActiveContract, contractEntry.activeContract) || contractEntry;
+	const createdEvent = firstRecord(jsActive.createdEvent, item.createdEvent, item.contract, jsActive) || {};
+	const createArgument = firstRecord(createdEvent.createArgument, createdEvent.create_argument, createdEvent.payload, item.payload) || {};
+	const contractId = firstString(createdEvent.contractId, createdEvent.contract_id, item.contractId, item.contract_id);
+	const templateId = firstString(createdEvent.templateId, createdEvent.template_id, jsActive.templateId, item.templateId, item.template_id);
+	const createdEventBlob = firstString(createdEvent.createdEventBlob, createdEvent.created_event_blob, createdEvent.eventBlob, item.createdEventBlob, item.created_event_blob, item.eventBlob);
+	const synchronizerId = firstString(jsActive.synchronizerId, jsActive.synchronizer_id, item.synchronizerId, item.synchronizer_id, item.domainId, item.domain_id);
+
+	if (!contractId && !templateId && !createdEventBlob) return null;
+
+	return {
+		contractEntry: {
+			JsActiveContract: {
+				...jsActive,
+				createdEvent: {
+					...createdEvent,
+					contractId,
+					templateId,
+					createArgument,
+					createdEventBlob,
+				},
+				synchronizerId,
+				templateId,
+			},
+		},
+	};
+}
+
+function normalizeContractsResponse(response: unknown): unknown[] {
+	return unwrapContractItems(response)
+		.map(normalizeContractItem)
+		.filter((entry): entry is unknown => entry !== null);
+}
+
+function extractErrorDetail(error: unknown): string {
+	if (!isRecord(error)) return String(error);
+	const response = isRecord(error.response) ? error.response : undefined;
+	const data = response && response.data !== undefined ? response.data : undefined;
+	if (typeof data === "string") return data;
+	if (isRecord(data)) return JSON.stringify(data);
+	if (typeof error.message === "string") return error.message;
+	return String(error);
+}
+
+function wrapConsoleSubmitError(error: unknown): Error {
+	const detail = extractErrorDetail(error);
+	return new Error(`[Temple SDK] Console wallet submit failed: ${detail}.`);
+}
+
+function normalizeLedgerCommand(command: unknown): Record<string, unknown> {
+	if (!isRecord(command) || !Array.isArray(command.commands)) {
+		throw new Error("[Temple SDK] Console wallet submitCommand() expects a ledger command with a commands array.");
+	}
+	return command;
+}
+
+export function createConsoleWalletAdapter(consoleWallet: unknown, options: ConsoleWalletAdapterOptions = {}): WalletAdapter {
+	const wallet = resolveConsoleWallet(consoleWallet);
+	let cachedPartyId: string | null = options.partyId || null;
+	let pendingPartyId: Promise<string | null> | null = null;
+
+	const loadPartyId = async (): Promise<string | null> => {
+		const account = await wallet.getPrimaryAccount();
+		cachedPartyId = extractPartyId(account);
+		pendingPartyId = null;
+		return cachedPartyId;
+	};
+
+	const ensurePartyId = async (): Promise<string | null> => {
+		if (cachedPartyId) return cachedPartyId;
+		if (!pendingPartyId) pendingPartyId = loadPartyId();
+		return pendingPartyId;
+	};
+
+	return defineWalletAdapter({
+		id: "console",
+		isServer: false,
+		getRawProvider: () => wallet,
+		getPartyId: ensurePartyId,
+
+		getActiveContracts: async (args) => {
+			const partyId = await ensurePartyId();
+			const templateIds = extractTemplateIds(args);
+			const parties = extractParties(args, partyId, options.parties);
+			if (templateIds.length === 0) {
+				throw new Error("[Temple SDK] Console wallet getActiveContracts() requires at least one templateId.");
+			}
+			if (parties.length === 0) {
+				throw new Error("[Temple SDK] Console wallet getActiveContracts() requires a party id from getPrimaryAccount() or adapter options.");
+			}
+			const response = await wallet.getContracts({
+				network: resolveNetwork(options.network),
+				parties,
+				templateIds,
+			});
+			return normalizeContractsResponse(response);
+		},
+
+		submitCommand: async (command) => {
+			// resolveConsoleWallet() guarantees at least one prepare method exists.
+			const prepareRequest = normalizeLedgerCommand(command) as unknown as ConsoleExecuteRequest;
+			const useWait =
+				typeof wallet.prepareExecuteAndWait === "function" &&
+				(options.waitForExecution !== false || typeof wallet.prepareExecute !== "function");
+			try {
+				return await (useWait ? wallet.prepareExecuteAndWait!(prepareRequest) : wallet.prepareExecute!(prepareRequest));
+			} catch (error) {
+				throw wrapConsoleSubmitError(error);
+			}
+		},
+
+		disconnect: async () => {
+			if (typeof wallet.disconnect === "function") await wallet.disconnect();
+		},
+	});
+}

package/src/canton/wallet/loop.ts

@@ -17,6 +17,10 @@
 
 import { defineWalletAdapter, type WalletAdapter } from "./adapter.js";
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 /** The Loop read/submit provider sub-object (or the Loop instance itself). */
 interface LoopProvider {
 	party_id?: string | null;
@@ -40,6 +44,18 @@ interface LoopLike extends LoopProvider {
 	payGas?: (trackingId: string) => Promise<unknown> | unknown;
 }
 
+export function isLoopWalletLike(value: unknown): boolean {
+	if (!isRecord(value)) return false;
+	const provider = isRecord(value.provider) ? value.provider : value;
+	return (
+		typeof provider.getActiveContracts === "function" &&
+		(typeof value.executeTransaction === "function" ||
+			typeof provider.submitTransaction === "function" ||
+			isRecord(value.session) ||
+			typeof provider.party_id === "string")
+	);
+}
+
 /**
  * Detect whether a Loop instance is server-side.
  * Loop-specific: server-side has null connection.ticketId and connection.ws.
@@ -59,6 +75,9 @@ export function createLoopWalletAdapter(loop: unknown): WalletAdapter {
 	if (!loop || typeof loop !== "object") {
 		throw new Error("[Temple SDK] createLoopWalletAdapter requires a Loop wallet instance.");
 	}
+	if (!isLoopWalletLike(loop)) {
+		throw new Error("[Temple SDK] createLoopWalletAdapter received an unsupported Loop wallet instance.");
+	}
 
 	const sdk = loop as LoopLike;
 	const isServer = detectServerSide(sdk);

package/src/canton/wallet/registry.ts

@@ -0,0 +1,26 @@
+import { isWalletAdapter, type WalletAdapter } from "./adapter.js";
+import { createConsoleWalletAdapter, isConsoleWalletLike } from "./console.js";
+import { createLoopWalletAdapter, isLoopWalletLike } from "./loop.js";
+
+type WalletAdapterFactory = {
+	id: string;
+	canWrap(value: unknown): boolean;
+	wrap(value: unknown): WalletAdapter;
+};
+
+const BUILT_IN_FACTORIES: WalletAdapterFactory[] = [
+	{ id: "console", canWrap: isConsoleWalletLike, wrap: (value) => createConsoleWalletAdapter(value) },
+	{ id: "loop", canWrap: isLoopWalletLike, wrap: createLoopWalletAdapter },
+];
+
+export function normalizeWalletAdapter(adapter: unknown): WalletAdapter {
+	if (isWalletAdapter(adapter)) return adapter;
+
+	for (const factory of BUILT_IN_FACTORIES) {
+		if (factory.canWrap(adapter)) return factory.wrap(adapter);
+	}
+
+	throw new Error(
+		"[Temple SDK] Unsupported wallet adapter. Pass a normalized adapter from createLoopWalletAdapter(), createConsoleWalletAdapter(), or defineWalletAdapter().",
+	);
+}

package/src/canton/wallet/service.ts

@@ -47,7 +47,7 @@ function requireAdapter(): WalletAdapter {
 // ── Required capabilities ──────────────────────────────────────────────────
 
 /** Resolve the active wallet's party id. Throws when no adapter is configured. */
-export function getPartyId(): string | null {
+export function getPartyId(): Promise<string | null> {
 	return requireAdapter().getPartyId();
 }
 

package/src/canton/walletAdapter.ts

@@ -4,7 +4,7 @@
  * Backward-compatible public surface for wallet interactions. The real wallet
  * architecture lives in ./wallet/ — a universal adapter contract (adapter.ts),
  * a service registry that dispatches capability calls (service.ts), and one
- * factory per wallet (loop.ts, and future providers). This module is a thin
+ * factory per wallet provider. This module is a thin
  * facade over that service so existing imports keep working unchanged.
  *
  * Adding a new wallet does not touch this file: write a create<Name>WalletAdapter()
@@ -17,20 +17,21 @@ import {
 	submitCommand as serviceSubmitCommand,
 	payDueGasIfAny as servicePayDueGasIfAny,
 } from "./wallet/service.js";
-import { isWalletAdapter } from "./wallet/adapter.js";
-import { createLoopWalletAdapter } from "./wallet/loop.js";
+import { normalizeWalletAdapter } from "./wallet/registry.js";
 import type { WalletAdapter } from "./wallet/adapter.js";
 
 // Re-export the adapter toolkit so consumers can build/register custom wallets.
 export { createLoopWalletAdapter } from "./wallet/loop.js";
+export { createConsoleWalletAdapter } from "./wallet/console.js";
 export { defineWalletAdapter, isWalletAdapter } from "./wallet/adapter.js";
 export type { WalletAdapter, WalletAdapterDefinition } from "./wallet/adapter.js";
+export type { ConsoleWalletAdapterOptions } from "./wallet/console.js";
 
 /**
  * Set the active wallet adapter.
  *
  * Accepts either a normalized adapter (from a create*WalletAdapter() factory) or
- * a raw Loop SDK instance, which is auto-wrapped for backward compatibility.
+ * a raw wallet instance recognized by a built-in wallet factory.
  * Pass a falsy value to clear the adapter.
  */
 export function setWalletAdapter(adapter: unknown): void {
@@ -38,8 +39,7 @@ export function setWalletAdapter(adapter: unknown): void {
 		setActiveAdapter(null);
 		return;
 	}
-	const normalized = isWalletAdapter(adapter) ? adapter : createLoopWalletAdapter(adapter);
-	setActiveAdapter(normalized);
+	setActiveAdapter(normalizeWalletAdapter(adapter));
 }
 
 /**
@@ -70,7 +70,7 @@ export function isServerMode(): boolean {
 /**
  * Get the party ID from the active wallet adapter, or null when none is set.
  */
-export function getAdapterPartyId(): string | null {
+export async function getAdapterPartyId(): Promise<string | null> {
 	const adapter = getActiveAdapter();
 	return adapter ? adapter.getPartyId() : null;
 }

package/src/canton/withdrawals.ts

@@ -77,7 +77,7 @@ export async function finalizeWithdrawFunds(
 ): Promise<Record<string, unknown>> {
 	const { allocationId, sender: senderOpt, assetId: rawAssetId, disclosures, userId } = opts;
 	const assetId = normalizeAssetId(rawAssetId);
-	const sender = getAdapterPartyId() ?? senderOpt ?? config.VALIDATOR_USER_PARTY_ID;
+	const sender = (await getAdapterPartyId()) ?? senderOpt ?? config.VALIDATOR_USER_PARTY_ID;
 
 	if (!allocationId || !sender || !assetId) {
 		const msg = "finalizeWithdrawFunds: allocationId, sender, and assetId are required";
@@ -345,7 +345,7 @@ export async function withdrawFunds(
 	const { amount, pollIntervalMs = 2000, maxPollAttempts = 30 } = opts || {};
 	const asset_id = normalizeAssetId(opts?.asset_id);
 
-	const sender = getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+	const sender = (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
 	if (!sender) {
 		const msg = "withdrawFunds: sender party is required. Connect a wallet adapter or configure VALIDATOR_USER_PARTY_ID.";
 		console.error(msg);
@@ -440,7 +440,7 @@ export async function withdrawDelegation(
 	user: string | null = null,
 	returnCommand = false,
 ): Promise<Record<string, unknown>> {
-	let resolvedUser = user ?? getAdapterPartyId() ?? config.VALIDATOR_USER_PARTY_ID;
+	let resolvedUser = user ?? (await getAdapterPartyId()) ?? config.VALIDATOR_USER_PARTY_ID;
 	let resolvedDelegationId = delegationId;
 
 	// If no delegationId passed, fetch it from the API

package/src/config/index.d.ts

@@ -20,6 +20,13 @@ export function setWalletAdapter(adapter: any): void;
 export function getWalletAdapter(): any;
 export function getAdapterProvider(): any;
 export function createLoopWalletAdapter(loop: any): any;
+export interface ConsoleWalletAdapterOptions {
+    network?: string;
+    partyId?: string;
+    parties?: string[];
+    waitForExecution?: boolean;
+}
+export function createConsoleWalletAdapter(consoleWallet: any, options?: ConsoleWalletAdapterOptions): any;
 export function defineWalletAdapter(definition: any): any;
 export function isWalletAdapter(value: any): boolean;
 export const NETWORK_LOCALHOST: "localhost";

package/src/config/index.js

@@ -12,6 +12,7 @@ export {
 	getWalletAdapter,
 	getAdapterProvider,
 	createLoopWalletAdapter,
+	createConsoleWalletAdapter,
 	defineWalletAdapter,
 	isWalletAdapter,
 } from "../../dist/canton/walletAdapter.js";