@canton-network/wallet-gateway-remote 1.4.0 → 1.6.0

package/dist/signing/signing-worker.js

@@ -0,0 +1,206 @@
+// Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { TransactionService } from '../ledger/transaction-service.js';
+import { resolveAutomationRunContext } from './service-account-session.js';
+/**
+ * Background poller that completes service-account transactions stuck in external
+ * custody approval.
+ *
+ * ## When this runs
+ *
+ * During M2M automation (`prepareExecute` → `signAndExecute`), external signing
+ * providers (Fireblocks, Blockdaemon, Dfns) may return `pending` instead of a
+ * signature. The gateway persists the transaction with `status: 'pending'` and
+ * an `externalTxId` from the provider. This worker picks up those rows on each
+ * tick via {@link Store.listAllPendingTransactions} (rows with an
+ * `externalTxId` are processed; others are skipped).
+ *
+ * Participant and wallet-kernel sign synchronously and never appear here.
+ *
+ * ## What happens on each tick
+ *
+ * For every pending row the worker resolves an M2M auth context
+ * ({@link resolveAutomationRunContext}), loads the user's primary wallet, and
+ * calls {@link TransactionService.signAndExecute}.
+ *
+ * Although the worker always invokes `signAndExecute`, **retries do not submit a
+ * new sign request**. `TransactionService.sign()` checks whether the stored
+ * transaction already has an `externalTxId`:
+ *
+ * - **First pass** (no `externalTxId`): `driver.signTransaction()` submits to
+ *   custody and stores the returned `externalTxId`.
+ * - **Subsequent ticks** (`externalTxId` present): `driver.getTransaction()`
+ *   polls the existing custody request for an updated status/signature.
+ *
+ * `signAndExecute` then:
+ *
+ * - returns early while the provider still reports `pending` (worker logs and
+ *   waits for the next tick), or
+ * - calls `execute()` once signing is `signed` (Dfns is special: it broadcasts
+ *   at sign-time, so execute only reconciles local state).
+ *
+ * A transaction is re-read before processing so a concurrent DApp call or an
+ * earlier tick that already completed it is skipped.
+ *
+ * ## Lifecycle
+ *
+ * Started once at gateway init (`start()`). Ticks are serialized: if a tick is
+ * still running, the next interval callback is a no-op. Use `stop()` on shutdown.
+ */
+export class SigningWorker {
+    constructor(options) {
+        this.options = options;
+        this.running = false;
+    }
+    /** Starts the interval timer. Idempotent if already started. */
+    start() {
+        this.options.logger.info('Starting signing worker');
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.options.intervalMs);
+        this.options.logger.info({ intervalMs: this.options.intervalMs }, 'Signing worker started');
+    }
+    /** Clears the interval timer. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /**
+     * One poll cycle: list all pending transactions and attempt to complete
+     * external-custody rows via {@link processPending}. Safe to call directly in
+     * tests.
+     */
+    async tick() {
+        this.options.logger.trace(`Signing worker: executing a tick`);
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        try {
+            const pending = await this.options.store.listAllPendingTransactions();
+            for (const tx of pending) {
+                if (!tx.externalTxId) {
+                    continue;
+                }
+                await this.processPending(tx);
+            }
+        }
+        catch (error) {
+            this.options.logger.error({ err: error }, 'Signing worker tick failed');
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /**
+     * Drives a single pending transaction through `signAndExecute`. Skips when
+     * automation context, submitting wallet, or refreshed `pending` status is missing.
+     * Errors are logged per transaction; other rows in the same tick still run.
+     */
+    async processPending(transaction) {
+        const logger = this.options.logger;
+        const { userId, networkId, externalTxId } = transaction;
+        if (!externalTxId || !userId || !networkId) {
+            logger.debug({ transaction }, 'Skipping signing worker tick: missing required fields');
+            return;
+        }
+        const runContext = await resolveAutomationRunContext(this.options.store, userId, networkId, logger);
+        if (!runContext) {
+            logger.debug({ runContext, transactionId: transaction.id }, 'Skipping signing worker tick: no run context');
+            return;
+        }
+        const store = runContext.scopedStore;
+        const wallet = await resolveWalletFromTransaction(transaction, store, logger);
+        if (!wallet) {
+            logger.warn({
+                userId,
+                networkId,
+                transactionId: transaction.id,
+                commandId: transaction.commandId,
+            }, 'Skipping signing worker tick: could not deduce submitting wallet from transaction payload');
+            return;
+        }
+        const refreshedTx = await store.getTransaction(transaction.id);
+        if (!refreshedTx || refreshedTx.status !== 'pending') {
+            logger.debug({ refreshedTx }, 'Skipping signing worker tick: transaction no longer pending');
+            return;
+        }
+        const notifier = this.options.notificationService.getNotifier(userId);
+        const transactionLogger = this.options.logger.child({
+            component: 'TransactionService',
+        });
+        const transactionService = new TransactionService(store, transactionLogger, this.options.signingDrivers, notifier);
+        try {
+            const result = await transactionService.signAndExecute(runContext.authContext, runContext.network, wallet, refreshedTx);
+            if ('status' in result && result.status === 'pending') {
+                logger.info({
+                    userId,
+                    networkId,
+                    transactionId: transaction.id,
+                    commandId: transaction.commandId,
+                    externalTxId: result.externalTxId,
+                    signingProviderId: wallet.signingProviderId,
+                }, 'Signing worker: transaction still awaiting external signing');
+            }
+            else {
+                logger.info({
+                    userId,
+                    networkId,
+                    transactionId: transaction.id,
+                    commandId: transaction.commandId,
+                    externalTxId: transaction.externalTxId,
+                    partyId: wallet.partyId,
+                    signingProviderId: wallet.signingProviderId,
+                    result,
+                }, 'Signing worker completed service account transaction');
+            }
+        }
+        catch (error) {
+            logger.error({
+                err: error,
+                userId,
+                networkId,
+                transactionId: transaction.id,
+                commandId: transaction.commandId,
+                externalTxId: transaction.externalTxId,
+                partyId: wallet.partyId,
+                signingProviderId: wallet.signingProviderId,
+            }, 'Signing worker failed to complete service account transaction');
+        }
+    }
+}
+/**
+ * Given the transaction, attempt to resolve the original wallet that submitted it.
+ * It's not guaranteed that the primary wallet was used, so we check the `actAs` field in the payload and find a wallet with a matching party ID.
+ *
+ * Returns `undefined` if the wallet cannot be resolved.
+ */
+async function resolveWalletFromTransaction(tx, store, logger) {
+    logger.debug({ tx, store }, 'Resolving wallet from transaction payload');
+    // first see if we can determine the wallet from the payload's actAs field.
+    // If not, we will default to the primary wallet.
+    let wallet = undefined;
+    const payload = tx.payload;
+    if (payload && typeof payload === 'object') {
+        const actAs = payload.actAs;
+        if (Array.isArray(actAs) && actAs.length !== 0) {
+            if (actAs.length > 1) {
+                logger.warn({ actAs }, 'Transaction has multiple acting parties; using the first one to resolve wallet');
+            }
+            const partyId = actAs[0];
+            const wallets = await store.getAllWallets();
+            wallet = wallets.find((wallet) => wallet.partyId === partyId);
+        }
+    }
+    if (!wallet) {
+        // No actAs was given: lets default to the primary party.
+        wallet = await store.getPrimaryWallet();
+        logger.debug({ wallet, tx }, 'Transaction has no actAs; using primary wallet');
+    }
+    return wallet;
+}

package/dist/signing/signing-worker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=signing-worker.test.d.ts.map

package/dist/signing/signing-worker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-worker.test.d.ts","sourceRoot":"","sources":["../../src/signing/signing-worker.test.ts"],"names":[],"mappings":""}

package/dist/signing/signing-worker.test.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { pino } from 'pino';
+import { sink } from 'pino-test';
+import { SigningWorker } from './signing-worker.js';
+import { SigningProvider } from '@canton-network/core-signing-lib';
+const mocks = vi.hoisted(() => ({
+    signAndExecute: vi.fn().mockResolvedValue({ commandId: 'cmd-1' }),
+}));
+vi.mock('@canton-network/core-wallet-auth', async () => {
+    const actual = await vi.importActual('@canton-network/core-wallet-auth');
+    return {
+        ...actual,
+        AuthTokenProvider: {
+            fromGatewayConfig: vi.fn().mockReturnValue({
+                getAuthContext: vi.fn().mockResolvedValue({
+                    userId: 'service_account',
+                    accessToken: 'abc',
+                }),
+            }),
+        },
+    };
+});
+vi.mock('../ledger/transaction-service.js', () => ({
+    TransactionService: vi.fn(function TransactionServiceMock() {
+        return { signAndExecute: mocks.signAndExecute };
+    }),
+}));
+const idp = {
+    id: 'idp1',
+    type: 'oauth',
+    issuer: 'https://issuer.example',
+    configUrl: 'https://issuer.example/.well-known/openid-configuration',
+};
+const m2mNetwork = {
+    id: 'net-m2m',
+    name: 'm2m',
+    description: '',
+    synchronizerId: 'sync::fp',
+    identityProviderId: 'idp1',
+    ledgerApi: { baseUrl: 'http://ledger' },
+    auth: {
+        method: 'authorization_code',
+        clientId: 'user',
+        audience: 'aud',
+        scope: 'scope',
+    },
+    serviceAccountAuth: {
+        method: 'client_credentials',
+        clientId: 'svc',
+        clientSecret: 'secret',
+        audience: 'aud',
+        scope: 'scope',
+    },
+};
+const wallet = {
+    primary: true,
+    partyId: 'party::ns',
+    status: 'allocated',
+    hint: 'party',
+    publicKey: 'pk',
+    namespace: 'ns',
+    networkId: 'net-m2m',
+    signingProviderId: SigningProvider.FIREBLOCKS,
+    rights: [],
+};
+const aliceWallet = {
+    primary: false,
+    partyId: 'alice::ns2',
+    status: 'allocated',
+    hint: 'alice',
+    publicKey: 'pk2',
+    namespace: 'ns2',
+    networkId: 'net-m2m',
+    signingProviderId: SigningProvider.FIREBLOCKS,
+    rights: [],
+};
+const pendingTransaction = {
+    id: 'tx-1',
+    commandId: 'cmd-1',
+    status: 'pending',
+    preparedTransaction: 'blob',
+    preparedTransactionHash: 'hash',
+    externalTxId: 'ext-1',
+    origin: null,
+    userId: 'user-1',
+    networkId: 'net-m2m',
+};
+function createWorker(storeOverrides = {}) {
+    const scopedStore = {
+        setSession: vi.fn().mockResolvedValue(undefined),
+        getPrimaryWallet: vi.fn().mockResolvedValue(wallet),
+        getAllWallets: vi.fn().mockResolvedValue([wallet, aliceWallet]),
+        getTransaction: vi.fn().mockResolvedValue(pendingTransaction),
+    };
+    const store = {
+        listAllPendingTransactions: vi
+            .fn()
+            .mockResolvedValue([pendingTransaction]),
+        getIdp: vi.fn().mockResolvedValue(idp),
+        getNetwork: vi.fn().mockResolvedValue(m2mNetwork),
+        withAuthContext: vi.fn().mockReturnValue(scopedStore),
+        ...storeOverrides,
+    };
+    const logger = pino({ level: 'silent' }, sink());
+    return {
+        worker: new SigningWorker({
+            intervalMs: 1000,
+            signingDrivers: {},
+            store: store,
+            notificationService: {
+                getNotifier: vi.fn(() => ({ emit: vi.fn() })),
+            },
+            logger,
+        }),
+        store,
+        scopedStore,
+    };
+}
+describe('SigningWorker', () => {
+    afterEach(() => vi.clearAllMocks());
+    it('completes pending external transactions with a primary wallet', async () => {
+        const { worker } = createWorker();
+        await worker.tick();
+        expect(mocks.signAndExecute.mock.calls[0][2].partyId).toBe('party::ns');
+    });
+    it('uses a non-primary wallet when actAs payload is present', async () => {
+        const { worker } = createWorker({
+            listAllPendingTransactions: vi.fn().mockResolvedValue([
+                {
+                    ...pendingTransaction,
+                    payload: { actAs: ['alice::ns2'] },
+                },
+            ]),
+        });
+        await worker.tick();
+        expect(mocks.signAndExecute).toHaveBeenCalledOnce();
+        expect(mocks.signAndExecute.mock.calls[0][2].partyId).toBe('alice::ns2');
+    });
+    it('skips pending transactions without an externalTxId', async () => {
+        const { worker } = createWorker({
+            listAllPendingTransactions: vi
+                .fn()
+                .mockResolvedValue([
+                { ...pendingTransaction, externalTxId: undefined },
+            ]),
+        });
+        await worker.tick();
+        expect(mocks.signAndExecute).not.toHaveBeenCalled();
+    });
+});

package/dist/user-api/controller.d.ts

@@ -3,9 +3,8 @@ import { Logger } from 'pino';
 import { NotificationService } from '../notification/NotificationService.js';
 import { AuthContext } from '@canton-network/core-wallet-auth';
 import { KernelInfo } from '../config/Config.js';
-import { SigningDriverInterface, SigningProvider } from '@canton-network/core-signing-lib';
-type AvailableSigningDrivers = Partial<Record<SigningProvider, SigningDriverInterface>>;
-export declare const userController: (kernelInfo: KernelInfo, userUrl: string, store: Store, notificationService: NotificationService, authContext: AuthContext | undefined, drivers: AvailableSigningDrivers, _logger: Logger, adminUserId?: string) => {
+import type { SigningDrivers } from '../signing/signing-drivers.js';
+export declare const userController: (kernelInfo: KernelInfo, userUrl: string, store: Store, notificationService: NotificationService, authContext: AuthContext | undefined, drivers: SigningDrivers, _logger: Logger, adminUserId?: string) => {
     addNetwork: import("./rpc-gen/typings.js").AddNetwork;
     removeNetwork: import("./rpc-gen/typings.js").RemoveNetwork;
     listNetworks: import("./rpc-gen/typings.js").ListNetworks;
@@ -34,6 +33,9 @@ export declare const userController: (kernelInfo: KernelInfo, userUrl: string, s
     listTransactions: import("./rpc-gen/typings.js").ListTransactions;
     deleteTransaction: import("./rpc-gen/typings.js").DeleteTransaction;
     getUser: import("./rpc-gen/typings.js").GetUser;
+    generateApiKey: import("./rpc-gen/typings.js").GenerateApiKey;
+    listApiKeys: import("./rpc-gen/typings.js").ListApiKeys;
+    removeApiKey: import("./rpc-gen/typings.js").RemoveApiKey;
+    listSigningProviderVaults: import("./rpc-gen/typings.js").ListSigningProviderVaults;
 };
-export {};
 //# sourceMappingURL=controller.d.ts.map

package/dist/user-api/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/user-api/controller.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,KAAK,EAAW,MAAM,mCAAmC,CAAA;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAEH,WAAW,EAMd,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAEH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AAUzC,KAAK,uBAAuB,GAAG,OAAO,CAClC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,cAAc,GACvB,YAAY,UAAU,EACtB,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,GAAG,SAAS,EACpC,SAAS,uBAAuB,EAChC,SAAS,MAAM,EACf,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwhCvB,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/user-api/controller.ts"],"names":[],"mappings":"AA+CA,OAAO,EAAE,KAAK,EAAW,MAAM,mCAAmC,CAAA;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAEH,WAAW,EAKd,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAYnE,eAAO,MAAM,cAAc,GACvB,YAAY,UAAU,EACtB,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,GAAG,SAAS,EACpC,SAAS,cAAc,EACvB,SAAS,MAAM,EACf,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgiCvB,CAAA"}