@canton-network/wallet-gateway-remote 1.3.0 → 1.5.0

package/dist/dapp-api/controller.js

@@ -4,7 +4,8 @@ import { assertConnected, AuthTokenProvider, } from '@canton-network/core-wallet
 import buildController from './rpc-gen/index.js';
 import { LedgerClient, } from '@canton-network/core-ledger-client';
 import { v4 } from 'uuid';
-import { networkStatus, ledgerPrepareParams } from '../utils.js';
+import { networkStatus, ledgerPrepareParams, logDynamically } from '../utils.js';
+import { rpcErrors } from '@canton-network/core-rpc-errors';
 export const dappController = (kernelInfo, dappUrl, userUrl, store, notificationService, _logger, origin, context) => {
     const logger = _logger.child({ component: 'dapp-controller' });
     return buildController({
@@ -127,6 +128,7 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
         },
         prepareExecute: async (params) => {
             const wallet = await store.getPrimaryWallet();
+            const wallets = await store.getWallets();
             const network = await store.getCurrentNetwork();
             if (context === undefined) {
                 throw new Error('Unauthenticated context');
@@ -134,26 +136,54 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             if (wallet === undefined) {
                 throw new Error('No primary wallet found');
             }
+            let userId = context.userId;
+            const accessTokenProvider = AuthTokenProvider.fromToken(context.accessToken, logger);
+            if (context?.isApiKey) {
+                logger.info('Authenticated with API Key, fetching m2m token for ledger access');
+                userId = context.ledgerUserId;
+            }
             const ledgerClient = new LedgerClient({
                 baseUrl: new URL(network.ledgerApi.baseUrl),
                 logger,
-                accessTokenProvider: AuthTokenProvider.fromToken(context.accessToken, logger),
+                accessTokenProvider,
             });
-            const userId = context.userId;
             const notifier = notificationService.getNotifier(userId);
-            params.commandId = params.commandId || v4();
-            const commandId = params.commandId;
+            const commandId = params.commandId || v4();
             const transactionId = v4();
             notifier.emit('txChanged', { status: 'pending', commandId });
             const synchronizerId = network.synchronizerId ??
                 (await ledgerClient.getSynchronizerId());
-            const response = await prepareSubmission(context.userId, wallet.partyId, synchronizerId, params, ledgerClient);
+            let actAs = [wallet.partyId];
+            if (params.actAs && params.actAs.length > 0) {
+                actAs = params.actAs;
+                for (const actingParty of actAs) {
+                    if (wallets.find((w) => w.partyId === actingParty) ===
+                        undefined) {
+                        throw rpcErrors.invalidRequest(`Acting party ${actingParty} does not belong to user`);
+                    }
+                }
+            }
+            logDynamically(logger, 'prepareExecute: Submitting request to ledger', {
+                info: { transactionId },
+                debug: { commandId, userId, actAs },
+            });
+            const actAsParty = params.actAs || [wallet.partyId];
+            const prepared = await prepareSubmission(context.userId, actAsParty, synchronizerId, params, ledgerClient);
+            logDynamically(logger, 'prepareExecute: Received response from ledger', {
+                info: { transactionId },
+                debug: {
+                    commandId,
+                    userId,
+                    partyId: actAsParty,
+                    prepared,
+                },
+            });
             const transaction = {
                 id: transactionId,
                 commandId,
                 status: 'pending',
-                preparedTransaction: response.preparedTransaction,
-                preparedTransactionHash: response.preparedTransactionHash,
+                preparedTransaction: prepared.preparedTransaction,
+                preparedTransactionHash: prepared.preparedTransactionHash,
                 payload: params,
                 origin: origin || null,
                 createdAt: new Date(),
@@ -161,10 +191,10 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             logger.info({
                 actAs: params.actAs || [wallet.partyId],
                 readAs: params.readAs || [],
-                userId: context.userId,
+                userId,
                 commandId,
                 commands: params.commands?.[0],
-                confirmationRequestTrafficCostEstimation: response.costEstimation
+                confirmationRequestTrafficCostEstimation: prepared.costEstimation
                     ?.confirmationRequestTrafficCostEstimation,
             }, 'prepared transaction traffic estimation');
             await store.setTransaction(transaction);
@@ -221,21 +251,9 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                 userUrl: `${userUrl}/login/`,
             };
         },
-        connected: async () => {
-            throw new Error('Only for events.');
-        },
-        onStatusChanged: async () => {
-            throw new Error('Only for events.');
-        },
-        accountsChanged: async () => {
-            throw new Error('Only for events.');
-        },
         listAccounts: async () => {
             return await store.getWallets();
         },
-        txChanged: async () => {
-            throw new Error('Only for events.');
-        },
         getActiveNetwork: async () => {
             const network = await store.getCurrentNetwork();
             return {
@@ -246,8 +264,36 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                     : {}),
             };
         },
-        signMessage: function () {
-            throw new Error('Function not implemented.');
+        signMessage: async (params) => {
+            if (!params?.message)
+                throw new Error('Message is required');
+            const wallet = await store.getPrimaryWallet();
+            if (context === undefined) {
+                throw new Error('Unauthenticated context');
+            }
+            if (wallet === undefined) {
+                throw new Error('No primary wallet found');
+            }
+            const notifier = notificationService.getNotifier(context.userId);
+            const messageId = v4();
+            await store.setMessageRaw({
+                id: messageId,
+                status: 'pending',
+                userId: context.userId,
+                partyId: wallet.partyId,
+                publicKey: wallet.publicKey,
+                message: params.message,
+                origin: origin || null,
+                createdAt: new Date(),
+            });
+            notifier.emit('messageSignature', {
+                status: 'pending',
+                messageId,
+            });
+            return {
+                messageId,
+                userUrl: `${userUrl}/sign-message/index.html?messageId=${messageId}&closeafteraction`,
+            };
         },
         getPrimaryAccount: async function () {
             const wallet = await store.getPrimaryWallet();
@@ -256,8 +302,23 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             }
             return wallet;
         },
+        connected: async () => {
+            throw new Error('Only for events.');
+        },
+        onStatusChanged: async () => {
+            throw new Error('Only for events.');
+        },
+        accountsChanged: async () => {
+            throw new Error('Only for events.');
+        },
+        txChanged: async () => {
+            throw new Error('Only for events.');
+        },
+        messageSignature: function () {
+            throw new Error('Only for events.');
+        },
     });
 };
-async function prepareSubmission(userId, partyId, synchronizerId, params, ledgerClient) {
-    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', ledgerPrepareParams(userId, partyId, synchronizerId, params));
+async function prepareSubmission(userId, partyIds, synchronizerId, params, ledgerClient) {
+    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', ledgerPrepareParams(userId, partyIds, synchronizerId, params));
 }

package/dist/dapp-api/controller.test.d.ts

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

package/dist/dapp-api/controller.test.d.ts.map

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