@temple-digital-group/temple-canton-js 2.0.0-beta.9 → 2.0.1

package/dist/canton/deposits.js

@@ -2,7 +2,7 @@ import config from "../../src/config/index.js";
 import axios from "axios";
 import { getDisclosures } from "../api/index.js";
 import { getUserId } from "../api/tokenStore.js";
-import { getAdapterPartyId, getWalletAdapter, submitCommand } from "../../src/canton/walletAdapter.js";
+import { getAdapterPartyId, getWalletAdapter, submitCommand, payDueGasIfAny } from "../../src/canton/walletAdapter.js";
 import { normalizeAssetId, instrumentCatalog } from "../../src/canton/instrumentCatalog.js";
 import { randomUUID, shouldUseLedgerForMetadata, normalizeContractId, resolveInstrumentDefinition, getInstrumentRegistrar, resolveProvider, dedupeDisclosedContracts, buildHeaders, DEFAULT_UTILITY_CONTEXT_KEYS, } from "./helpers.js";
 import { resolveAmuletContext, resolveUtilityInstrumentConfiguration, resolveUtilityAllocationFactory, getAmuletHoldingsForParty, getUtilityHoldingsForParty, getUtxoCount, } from "../../src/canton/index.js";
@@ -114,6 +114,8 @@ export async function deposit(amount, symbol) {
     if (!party) {
         return { error: "deposit: could not resolve party ID from wallet adapter." };
     }
+    // Pay any outstanding network gas first so the balance check below is accurate.
+    await payDueGasIfAny();
     const assetId = normalizeAssetId(symbol);
     if (!instrumentCatalog[assetId]) {
         return { error: `deposit: unsupported symbol "${symbol}"` };
@@ -442,6 +444,7 @@ export async function depositFunds(opts, returnCommand = false) {
     // Auto-submit via wallet adapter if available
     if (getWalletAdapter()) {
         try {
+            await payDueGasIfAny();
             return (await submitCommand(command));
         }
         catch (error) {

package/dist/canton/withdrawals.d.ts

@@ -17,6 +17,13 @@ export interface FinalizeWithdrawOpts {
     };
     userId?: string;
 }
+export interface BulkWithdrawFundsOpts {
+    allocationIds: string[];
+    sender?: string;
+    assetId: string;
+    disclosures?: FinalizeWithdrawOpts["disclosures"];
+    userId?: string;
+}
 export interface WithdrawFundsOpts {
     asset_id: string;
     amount: string | number;
@@ -32,6 +39,19 @@ export interface WithdrawFundsOpts {
  * 3. Remote: Scan API / Registry API
  */
 export declare function finalizeWithdrawFunds(opts: FinalizeWithdrawOpts, returnCommand?: boolean): Promise<Record<string, unknown>>;
+/**
+ * Finalize multiple withdrawals in a single signed transaction.
+ *
+ * Bundles N Allocation_Withdraw exercises into one ledger submission so the user
+ * signs once for the whole batch. All allocations must belong to the same sender
+ * and the same asset (caller's responsibility — pass one assetId).
+ *
+ * Choice-context fetching:
+ * - Localhost ledger / Amulet via /api/amulet/disclosures: one shared context for all N.
+ * - Scan API (Amulet) / Registry API (utility): one fetch per allocation, then disclosed
+ *   contracts merged and deduped.
+ */
+export declare function bulkWithdrawFunds(opts: BulkWithdrawFundsOpts, returnCommand?: boolean): Promise<Record<string, unknown>>;
 /**
  * High-level withdrawal flow:
  * 1. Creates a withdrawal request via the backend API.

package/dist/canton/withdrawals.js

@@ -2,10 +2,12 @@ import config from "../../src/config/index.js";
 import axios from "axios";
 import { getDisclosures, createWithdrawalRequest, getWithdrawalRequestStatus, getDelegation, } from "../api/index.js";
 import { getUserId } from "../api/tokenStore.js";
-import { getAdapterPartyId, getWalletAdapter, submitCommand } from "../../src/canton/walletAdapter.js";
-import { randomUUID, shouldUseLedgerForMetadata, normalizeContractId, resolveInstrumentDefinition, getInstrumentRegistrar, dedupeDisclosedContracts, buildHeaders, DEFAULT_AMULET_CONTEXT_KEYS, DEFAULT_UTILITY_CONTEXT_KEYS, } from "./helpers.js";
-import { resolveAmuletContext, resolveUtilityInstrumentConfiguration, resolveUtilityAllocationFactory, } from "../../src/canton/index.js";
+import { getAdapterPartyId, getWalletAdapter, submitCommand, payDueGasIfAny } from "../../src/canton/walletAdapter.js";
+import { randomUUID, shouldUseLedgerForMetadata, normalizeContractId, resolveInstrumentDefinition, getInstrumentRegistrar, resolveProvider, dedupeDisclosedContracts, buildHeaders, DEFAULT_AMULET_CONTEXT_KEYS, DEFAULT_UTILITY_CONTEXT_KEYS, } from "./helpers.js";
+import { resolveAmuletContext, resolveUtilityInstrumentConfiguration, resolveUtilityAllocationFactory, getUtxoCount, } from "../../src/canton/index.js";
 import { normalizeAssetId } from "../../src/canton/instrumentCatalog.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+const CC_FEE_RESERVE = 10;
 // ─── Withdrawal Functions ────────────────────────────────────────────────────
 /**
  * Finalize a withdrawal by exercising the Allocation_Withdraw choice.
@@ -233,6 +235,7 @@ export async function finalizeWithdrawFunds(opts, returnCommand = false) {
     // Auto-submit via wallet adapter if available
     if (getWalletAdapter()) {
         try {
+            await payDueGasIfAny();
             return (await submitCommand(command));
         }
         catch (error) {
@@ -255,6 +258,271 @@ export async function finalizeWithdrawFunds(opts, returnCommand = false) {
         return { error: msg };
     }
 }
+/**
+ * Finalize multiple withdrawals in a single signed transaction.
+ *
+ * Bundles N Allocation_Withdraw exercises into one ledger submission so the user
+ * signs once for the whole batch. All allocations must belong to the same sender
+ * and the same asset (caller's responsibility — pass one assetId).
+ *
+ * Choice-context fetching:
+ * - Localhost ledger / Amulet via /api/amulet/disclosures: one shared context for all N.
+ * - Scan API (Amulet) / Registry API (utility): one fetch per allocation, then disclosed
+ *   contracts merged and deduped.
+ */
+export async function bulkWithdrawFunds(opts, returnCommand = false) {
+    const { allocationIds, sender: senderOpt, assetId: rawAssetId, disclosures, userId } = opts;
+    const assetId = normalizeAssetId(rawAssetId);
+    const sender = getAdapterPartyId() ?? senderOpt ?? config.VALIDATOR_USER_PARTY_ID;
+    if (!Array.isArray(allocationIds) || allocationIds.length === 0) {
+        const msg = "bulkWithdrawFunds: allocationIds must be a non-empty array";
+        console.error(msg);
+        return { error: msg };
+    }
+    if (!sender || !assetId) {
+        const msg = "bulkWithdrawFunds: sender and assetId are required";
+        console.error(msg);
+        return { error: msg };
+    }
+    const isAmulet = assetId === "Amulet";
+    const allocationCids = allocationIds.map((cid) => normalizeContractId(cid));
+    // Per-allocation choice context (one entry per allocation, in the same order).
+    // Shared-context paths fill all N entries with the same object.
+    let perAllocContexts = [];
+    let mergedDisclosedContracts = [];
+    if (shouldUseLedgerForMetadata()) {
+        // Localhost: resolve once, reuse for all allocations.
+        let sharedContext = {};
+        const sharedDisclosed = [];
+        if (isAmulet) {
+            const amuletCtx = await resolveAmuletContext({ investor: sender, holdingIds: [], transferAmount: 0 });
+            if (!amuletCtx) {
+                const msg = "bulkWithdrawFunds: failed to resolve Amulet context from ledger";
+                console.error(msg);
+                return { error: msg };
+            }
+            const ctx = amuletCtx;
+            const contextKeys = ctx.contextKeys;
+            const amuletRules = ctx.amuletRules;
+            const openMiningRound = ctx.openMiningRound;
+            const featuredAppRight = ctx.featuredAppRight;
+            const externalAmuletRules = ctx.externalAmuletRules;
+            sharedContext = {
+                values: {
+                    [contextKeys.amuletRules]: { tag: "AV_ContractId", value: amuletRules.contractCid },
+                    [contextKeys.openRound]: { tag: "AV_ContractId", value: openMiningRound.contractCid },
+                    [contextKeys.featuredAppRight]: { tag: "AV_ContractId", value: featuredAppRight.contractCid },
+                    [contextKeys.expireLock]: { tag: "AV_Bool", value: true },
+                },
+            };
+            sharedDisclosed.push({
+                templateId: amuletRules.templateId ?? null,
+                contractId: amuletRules.contractCid,
+                createdEventBlob: amuletRules.disclosureCid,
+                synchronizerId: amuletRules.synchronizerId,
+            }, {
+                templateId: openMiningRound.templateId ?? null,
+                contractId: openMiningRound.contractCid,
+                createdEventBlob: openMiningRound.disclosureCid,
+                synchronizerId: openMiningRound.synchronizerId,
+            }, {
+                templateId: externalAmuletRules.templateId ?? null,
+                contractId: externalAmuletRules.contractCid,
+                createdEventBlob: externalAmuletRules.disclosureCid,
+                synchronizerId: externalAmuletRules.synchronizerId,
+            });
+            if (featuredAppRight?.contractCid && featuredAppRight?.disclosureCid) {
+                sharedDisclosed.push({
+                    templateId: featuredAppRight.templateId ?? null,
+                    contractId: featuredAppRight.contractCid,
+                    createdEventBlob: featuredAppRight.disclosureCid,
+                    synchronizerId: featuredAppRight.synchronizerId,
+                });
+            }
+        }
+        else {
+            const instrumentDef = resolveInstrumentDefinition(assetId);
+            const networkDef = instrumentDef?.[config.NETWORK];
+            const registrar = networkDef?.registrar || getInstrumentRegistrar(assetId) || config.VALIDATOR_REGISTRAR_PARTY_ID;
+            const [allocFactory, instConfig] = await Promise.all([
+                resolveUtilityAllocationFactory(registrar, sender),
+                resolveUtilityInstrumentConfiguration(assetId, registrar),
+            ]);
+            if (instConfig) {
+                sharedContext = {
+                    values: {
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.instrumentConfiguration]: {
+                            tag: "AV_ContractId",
+                            value: instConfig.contractCid,
+                        },
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.instrumentConfigurationPrefixed]: {
+                            tag: "AV_ContractId",
+                            value: instConfig.contractCid,
+                        },
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.senderCredentials]: { tag: "AV_List", value: [] },
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.senderCredentialsPrefixed]: { tag: "AV_List", value: [] },
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.receiverCredentials]: { tag: "AV_List", value: [] },
+                        [DEFAULT_UTILITY_CONTEXT_KEYS.receiverCredentialsPrefixed]: { tag: "AV_List", value: [] },
+                        [DEFAULT_AMULET_CONTEXT_KEYS.expireLock]: { tag: "AV_Bool", value: true },
+                    },
+                };
+                sharedDisclosed.push({
+                    templateId: null,
+                    contractId: instConfig.contractCid,
+                    createdEventBlob: instConfig.disclosureCid,
+                    synchronizerId: instConfig.synchronizerId,
+                });
+            }
+            if (allocFactory) {
+                sharedDisclosed.push({
+                    templateId: null,
+                    contractId: allocFactory.contractCid,
+                    createdEventBlob: allocFactory.disclosureCid,
+                    synchronizerId: allocFactory.synchronizerId,
+                });
+            }
+        }
+        perAllocContexts = allocationCids.map(() => sharedContext);
+        mergedDisclosedContracts = sharedDisclosed;
+    }
+    else if (isAmulet && !config.VALIDATOR_SCAN_API_URL) {
+        // Amulet via /api/amulet/disclosures: one fetch shared across all allocations.
+        const factoryData = disclosures?.disclosures || disclosures || null;
+        let resolvedData = factoryData;
+        if (!resolvedData?.choiceContext) {
+            const disclosuresResult = (await getDisclosures(sender));
+            resolvedData = disclosuresResult?.disclosures;
+            if (disclosuresResult?.error || !resolvedData?.choiceContext) {
+                const detail = disclosuresResult?.message ||
+                    disclosuresResult?.error ||
+                    "missing choiceContext in response";
+                const msg = `bulkWithdrawFunds: failed to resolve Amulet disclosures: ${detail}`;
+                console.error(msg);
+                return { error: msg };
+            }
+        }
+        const choiceContext = resolvedData.choiceContext;
+        const sharedContext = choiceContext.choiceContextData || {};
+        const values = sharedContext.values;
+        if (values && !values[DEFAULT_AMULET_CONTEXT_KEYS.expireLock]) {
+            values[DEFAULT_AMULET_CONTEXT_KEYS.expireLock] = { tag: "AV_Bool", value: true };
+        }
+        const sharedDisclosed = (choiceContext.disclosedContracts || []).map((dc) => ({
+            templateId: dc.templateId,
+            contractId: dc.contractId,
+            createdEventBlob: dc.createdEventBlob,
+            synchronizerId: dc.synchronizerId,
+        }));
+        perAllocContexts = allocationCids.map(() => sharedContext);
+        mergedDisclosedContracts = sharedDisclosed;
+    }
+    else {
+        // Per-allocation context: Scan API (Amulet) or Registry API (utility).
+        let baseUrl;
+        let contextHeaders = {};
+        if (isAmulet) {
+            if (!config.VALIDATOR_SCAN_API_URL) {
+                const msg = "bulkWithdrawFunds: VALIDATOR_SCAN_API_URL is required for Amulet allocations";
+                console.error(msg);
+                return { error: msg };
+            }
+            baseUrl = `${config.VALIDATOR_SCAN_API_URL}/registry`;
+            contextHeaders = await buildHeaders();
+        }
+        else {
+            const instrumentDef = resolveInstrumentDefinition(assetId);
+            const networkContracts = instrumentDef?.[config.NETWORK];
+            const registryAPI = networkContracts?.registryAPI;
+            if (!registryAPI) {
+                const msg = `bulkWithdrawFunds: no registryAPI defined for ${assetId} on ${config.NETWORK}`;
+                console.error(msg);
+                return { error: msg };
+            }
+            baseUrl = registryAPI;
+        }
+        const requestConfig = Object.keys(contextHeaders).length > 0 ? { headers: contextHeaders } : undefined;
+        try {
+            const contextResults = await Promise.all(allocationCids.map(async (cid) => {
+                const url = `${baseUrl}/allocations/v1/${encodeURIComponent(cid)}/choice-contexts/withdraw`;
+                try {
+                    const resp = await axios.post(url, { meta: {}, excludeDebugFields: true }, requestConfig);
+                    return resp.data;
+                }
+                catch (error) {
+                    const axiosErr = error;
+                    const detail = axiosErr.response?.data ? JSON.stringify(axiosErr.response.data) : axiosErr.message;
+                    throw new Error(`bulkWithdrawFunds: error fetching withdraw context for ${cid} from ${isAmulet ? "Scan API" : "Registry API"}: ${detail}`);
+                }
+            }));
+            for (const data of contextResults) {
+                perAllocContexts.push(data?.choiceContextData || {});
+                const disclosed = (data?.disclosedContracts || []).map((dc) => ({
+                    templateId: dc.templateId,
+                    contractId: dc.contractId,
+                    createdEventBlob: dc.createdEventBlob,
+                    synchronizerId: dc.synchronizerId,
+                }));
+                mergedDisclosedContracts.push(...disclosed);
+            }
+        }
+        catch (error) {
+            const msg = error.message;
+            console.error(msg);
+            return { error: msg };
+        }
+    }
+    // Build one ExerciseCommand per allocation; Canton signs the whole submission atomically.
+    const exerciseCommands = allocationCids.map((cid, idx) => ({
+        ExerciseCommand: {
+            templateId: "#splice-api-token-allocation-v1:Splice.Api.Token.AllocationV1:Allocation",
+            contractId: cid,
+            choice: "Allocation_Withdraw",
+            choiceArgument: {
+                extraArgs: {
+                    context: perAllocContexts[idx],
+                    meta: { values: {} },
+                },
+            },
+        },
+    }));
+    const command = {
+        commands: exerciseCommands,
+        commandId: randomUUID(),
+        userId: userId || getUserId() || config.AUTH0_USER_ID || "temple",
+        applicationId: "temple",
+        actAs: [sender],
+        disclosedContracts: mergedDisclosedContracts,
+    };
+    dedupeDisclosedContracts(command);
+    const endpoint = `${config.VALIDATOR_API_URL}/v2/commands/submit-and-wait`;
+    if (returnCommand) {
+        return { command, endpoint };
+    }
+    if (getWalletAdapter()) {
+        try {
+            await payDueGasIfAny();
+            return (await submitCommand(command));
+        }
+        catch (error) {
+            const msg = `bulkWithdrawFunds: wallet adapter submission failed: ${error.message}`;
+            console.error(msg);
+            return { error: msg };
+        }
+    }
+    const headers = await buildHeaders();
+    try {
+        const response = await axios.post(endpoint, command, { headers });
+        return response.data;
+    }
+    catch (error) {
+        const axiosErr = error;
+        const errorData = axiosErr?.response?.data;
+        const errorDetail = errorData ? JSON.stringify(errorData, null, 2) : axiosErr.message;
+        const msg = `bulkWithdrawFunds: error submitting command: ${errorDetail}`;
+        console.error(msg);
+        return { error: msg };
+    }
+}
 /**
  * High-level withdrawal flow:
  * 1. Creates a withdrawal request via the backend API.
@@ -270,6 +538,18 @@ export async function withdrawFunds(opts, returnCommand = false) {
         console.error(msg);
         return { error: msg };
     }
+    // Pay any outstanding network gas first so the fee-reserve check below is accurate.
+    await payDueGasIfAny();
+    // Ensure the user has enough CC unlocked to pay gas for the eventual Allocation_Withdraw.
+    const provider = resolveProvider(null);
+    const ccBalance = await getUtxoCount(sender, "Amulet", provider);
+    const availableCC = ccBalance.unlockedBalance || 0;
+    if (availableCC < CC_FEE_RESERVE) {
+        return {
+            error: `withdrawFunds: insufficient CC for fees. You have ${availableCC} CC but need at least ${CC_FEE_RESERVE} CC to cover transaction fees.`,
+            data: { ccBalance: availableCC, feeReserve: CC_FEE_RESERVE },
+        };
+    }
     // 1. Submit the withdrawal request
     const createResult = (await createWithdrawalRequest(asset_id, amount));
     if (createResult?.error) {
@@ -368,6 +648,7 @@ export async function withdrawDelegation(delegationId = null, user = null, retur
     // Auto-submit via wallet adapter if available
     if (getWalletAdapter()) {
         try {
+            await payDueGasIfAny();
             return (await submitCommand(command));
         }
         catch (error) {

package/index.js

@@ -1,15 +1,15 @@
-// Export Canton client functions
-export * from './src/canton/index.js';
-
-// Export Auth0 utilities
-export { getJWTToken } from './src/auth0/index.js';
-
-// Export configuration
-export * from './src/config/index.js';
-
-// Export Temple REST API functions
-export * from './dist/api/index.js';
-
-// Export WebSocket client
-export * from './dist/websocket/index.js';
-
+// Export Canton client functions
+export * from './src/canton/index.js';
+
+// Export Auth0 utilities
+export { getJWTToken } from './src/auth0/index.js';
+
+// Export configuration
+export * from './src/config/index.js';
+
+// Export Temple REST API functions
+export * from './dist/api/index.js';
+
+// Export WebSocket client
+export * from './dist/websocket/index.js';
+

package/package.json

@@ -1,49 +1,49 @@
-{
-  "name": "@temple-digital-group/temple-canton-js",
-  "version": "2.0.0-beta.9",
-  "description": "JavaScript library for interacting with Temple Canton blockchain",
-  "type": "module",
-  "main": "index.js",
-  "exports": {
-    ".": "./index.js"
-  },
-  "files": [
-    "index.js",
-    "src/",
-    "dist/"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Temple-Digital-Group/temple-canton-js.git"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "author": "kakashigr <augegr@gmail.com>",
-  "keywords": [
-    "canton",
-    "blockchain",
-    "daml",
-    "splice",
-    "amulet",
-    "ledger",
-    "trading",
-    "temple"
-  ],
-  "license": "MIT",
-  "scripts": {
-    "start": "node index.js",
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "axios": "^1.13.1",
-    "dotenv": "^17.2.3",
-    "ws": "^8.19.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.3.3",
-    "@types/ws": "^8.18.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@temple-digital-group/temple-canton-js",
+  "version": "2.0.1",
+  "description": "JavaScript library for interacting with Temple Canton blockchain",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "dist/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Temple-Digital-Group/temple-canton-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "kakashigr <augegr@gmail.com>",
+  "keywords": [
+    "canton",
+    "blockchain",
+    "daml",
+    "splice",
+    "amulet",
+    "ledger",
+    "trading",
+    "temple"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "start": "node index.js",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.13.1",
+    "dotenv": "^17.2.3",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/api/config.d.ts

@@ -1,20 +1,20 @@
-declare module "../../src/config/index.js" {
-	const config: {
-		readonly API_BASE_URL: string;
-		readonly API_EMAIL?: string;
-		readonly API_PASSWORD?: string;
-		readonly API_KEY?: string;
-		readonly NETWORK: string;
-		readonly VALIDATOR_API_URL: string;
-		readonly VALIDATOR_SCAN_API_URL: string;
-		readonly JWT_TOKEN: string;
-		[key: string]: unknown;
-	};
-	export default config;
-	export function initializeConfig(config: Record<string, unknown>): void;
-	export function setJWTToken(token: string): void;
-	export function getConfigValue(key: string): string | undefined;
-	export function setWalletAdapter(adapter: unknown): void;
-	export function getWalletAdapter(): unknown;
-	export function getAdapterProvider(): unknown;
-}
+declare module "../../src/config/index.js" {
+	const config: {
+		readonly API_BASE_URL: string;
+		readonly API_EMAIL?: string;
+		readonly API_PASSWORD?: string;
+		readonly API_KEY?: string;
+		readonly NETWORK: string;
+		readonly VALIDATOR_API_URL: string;
+		readonly VALIDATOR_SCAN_API_URL: string;
+		readonly JWT_TOKEN: string;
+		[key: string]: unknown;
+	};
+	export default config;
+	export function initializeConfig(config: Record<string, unknown>): void;
+	export function setJWTToken(token: string): void;
+	export function getConfigValue(key: string): string | undefined;
+	export function setWalletAdapter(adapter: unknown): void;
+	export function getWalletAdapter(): unknown;
+	export function getAdapterProvider(): unknown;
+}