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

package/dist/dapp-api/controller.test.js

@@ -0,0 +1,516 @@
+// Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { pino } from 'pino';
+import { sink } from 'pino-test';
+import { PartyLevelRight, } from '@canton-network/core-wallet-store';
+import { StoreInternal } from '@canton-network/core-wallet-store-inmemory';
+import { SigningProvider } from '@canton-network/core-signing-lib';
+import { NotificationService } from '../notification/NotificationService.js';
+import { dappController } from './controller.js';
+const ledgerMocks = vi.hoisted(() => ({
+    getWithRetry: vi.fn(),
+    postWithRetry: vi.fn(),
+    getSynchronizerId: vi.fn(),
+}));
+const mockNetworkStatus = vi.hoisted(() => vi.fn().mockResolvedValue({
+    isConnected: true,
+    reason: undefined,
+    cantonVersion: '3.4',
+}));
+const mockUuidV4 = vi.hoisted(() => vi.fn());
+vi.mock('@canton-network/core-ledger-client', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        LedgerClient: vi.fn(function LedgerClientMock() {
+            return {
+                getWithRetry: ledgerMocks.getWithRetry,
+                postWithRetry: ledgerMocks.postWithRetry,
+                getSynchronizerId: ledgerMocks.getSynchronizerId,
+            };
+        }),
+    };
+});
+vi.mock('../utils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        networkStatus: mockNetworkStatus,
+    };
+});
+vi.mock('uuid', () => ({
+    v4: mockUuidV4,
+}));
+const kernelInfo = {
+    id: 'kernel-test',
+    clientType: 'browser',
+};
+const dappUrl = 'https://dapp.api.example';
+const userUrl = 'https://user.api.example';
+const origin = 'https://dapp.example';
+const idp = {
+    id: 'idp1',
+    type: 'oauth',
+    issuer: 'http://auth',
+    configUrl: 'http://auth/.well-known/openid-configuration',
+};
+const storeNetwork = {
+    id: 'network1',
+    name: 'testnet',
+    synchronizerId: 'sync1::fingerprint',
+    description: 'Test',
+    identityProviderId: 'idp1',
+    ledgerApi: { baseUrl: 'http://ledger.test' },
+    auth: {
+        method: 'authorization_code',
+        clientId: 'cid',
+        scope: 'scope',
+        audience: 'aud',
+    },
+    adminAuth: {
+        method: 'client_credentials',
+        clientId: 'admin-cid',
+        clientSecret: 'admin-secret',
+        audience: 'admin-aud',
+        scope: 'admin-scope',
+    },
+};
+const auth = {
+    userId: 'user-1',
+    accessToken: 'access-token-1',
+};
+const session = {
+    id: 'session-1',
+    network: 'network1',
+    accessToken: 'session-token',
+};
+const primaryWallet = {
+    primary: true,
+    partyId: 'party::namespace',
+    status: 'allocated',
+    hint: 'party',
+    signingProviderId: SigningProvider.WALLET_KERNEL,
+    publicKey: 'wallet-public-key',
+    namespace: 'namespace',
+    networkId: 'network1',
+    rights: [PartyLevelRight.CanActAs],
+};
+async function createStore(logger, context, options = {}) {
+    const { withSession = true, withWallet = true } = options;
+    const store = new StoreInternal({ idps: [idp], networks: [storeNetwork] }, logger, context);
+    if (context && withSession) {
+        await store.setSession(session);
+    }
+    if (context && withWallet) {
+        await store.addWallet(primaryWallet);
+    }
+    return store;
+}
+function createController(store, notificationService, logger, context, requestOrigin = origin) {
+    return dappController(kernelInfo, dappUrl, userUrl, store, notificationService, logger, requestOrigin, context);
+}
+describe('dappController', () => {
+    let logger;
+    let notificationService;
+    beforeEach(() => {
+        logger = pino({ level: 'silent' }, sink());
+        notificationService = new NotificationService(logger);
+        ledgerMocks.getWithRetry.mockReset();
+        ledgerMocks.postWithRetry.mockReset();
+        ledgerMocks.getSynchronizerId.mockReset();
+        ledgerMocks.getSynchronizerId.mockResolvedValue('sync-from-ledger');
+        mockNetworkStatus.mockReset();
+        mockNetworkStatus.mockResolvedValue({
+            isConnected: true,
+            reason: undefined,
+            cantonVersion: '3.4',
+        });
+        mockUuidV4.mockReset();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('connect', () => {
+        it('returns unauthenticated when there is no auth context', async () => {
+            const store = await createStore(logger, auth, {
+                withSession: false,
+            });
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.connect()).resolves.toEqual({
+                isConnected: false,
+                isNetworkConnected: false,
+                networkReason: 'Unauthenticated',
+                userUrl: `${userUrl}/login/`,
+            });
+        });
+        it('returns unauthenticated when there is no session', async () => {
+            const store = await createStore(logger, auth, {
+                withSession: false,
+            });
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.connect()).resolves.toEqual({
+                isConnected: false,
+                isNetworkConnected: false,
+                networkReason: 'Unauthenticated',
+                userUrl: `${userUrl}/login/`,
+            });
+        });
+        it('connects and emits statusChanged and connected', async () => {
+            const store = await createStore(logger, auth);
+            const notifier = notificationService.getNotifier(auth.userId);
+            const emitSpy = vi.spyOn(notifier, 'emit');
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.connect();
+            expect(result).toMatchObject({
+                isConnected: true,
+                reason: 'OK',
+                isNetworkConnected: true,
+                networkReason: 'OK',
+                userUrl: `${userUrl}/login/`,
+            });
+            expect(mockNetworkStatus).toHaveBeenCalled();
+            expect(emitSpy).toHaveBeenCalledWith('statusChanged', expect.objectContaining({
+                connection: expect.objectContaining({
+                    isConnected: true,
+                }),
+                session: {
+                    accessToken: auth.accessToken,
+                    userId: auth.userId,
+                },
+            }));
+            expect(emitSpy).toHaveBeenCalledWith('connected', expect.objectContaining({
+                provider: expect.objectContaining({ id: kernelInfo.id }),
+            }));
+        });
+        it('reflects disconnected ledger in network status', async () => {
+            mockNetworkStatus.mockResolvedValue({
+                isConnected: false,
+                reason: 'Ledger unreachable',
+            });
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.connect();
+            expect(result).toMatchObject({
+                isConnected: true,
+                isNetworkConnected: false,
+                networkReason: 'Ledger unreachable',
+            });
+        });
+    });
+    describe('disconnect', () => {
+        it('returns null when there is no auth context', async () => {
+            const store = await createStore(logger, auth);
+            const removeSessionSpy = vi.spyOn(store, 'removeSession');
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.disconnect()).resolves.toBeNull();
+            expect(removeSessionSpy).not.toHaveBeenCalled();
+        });
+        it('removes the session and emits statusChanged', async () => {
+            const store = await createStore(logger, auth);
+            const notifier = notificationService.getNotifier(auth.userId);
+            const emitSpy = vi.spyOn(notifier, 'emit');
+            const controller = createController(store, notificationService, logger, auth);
+            await controller.disconnect();
+            await expect(store.getSession()).resolves.toBeUndefined();
+            expect(emitSpy).toHaveBeenCalledWith('statusChanged', expect.objectContaining({
+                connection: expect.objectContaining({
+                    isConnected: false,
+                    reason: 'disconnect',
+                }),
+            }));
+        });
+    });
+    describe('isConnected', () => {
+        it('returns unauthenticated when there is no session', async () => {
+            const store = await createStore(logger, auth, {
+                withSession: false,
+            });
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.isConnected()).resolves.toEqual({
+                isConnected: false,
+                isNetworkConnected: false,
+                networkReason: 'Unauthenticated',
+                userUrl: `${userUrl}/login/`,
+            });
+        });
+        it('returns connected status when authenticated', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.isConnected()).resolves.toEqual({
+                isConnected: true,
+                reason: 'OK',
+                isNetworkConnected: true,
+                networkReason: 'OK',
+                userUrl: `${userUrl}/login/`,
+            });
+        });
+    });
+    describe('status', () => {
+        it('returns unauthenticated status when there is no session', async () => {
+            const store = await createStore(logger, auth, {
+                withSession: false,
+            });
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.status();
+            expect(result.connection).toMatchObject({
+                isConnected: false,
+                reason: 'Unauthenticated',
+            });
+            expect(result.network).toBeUndefined();
+        });
+        it('returns full status when authenticated', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.status();
+            expect(result).toMatchObject({
+                provider: expect.objectContaining({ id: kernelInfo.id }),
+                connection: {
+                    isConnected: true,
+                    reason: 'OK',
+                    isNetworkConnected: true,
+                    networkReason: 'OK',
+                },
+                network: {
+                    networkId: storeNetwork.id,
+                    ledgerApi: storeNetwork.ledgerApi.baseUrl,
+                    accessToken: auth.accessToken,
+                },
+                session: {
+                    id: session.id,
+                    accessToken: auth.accessToken,
+                    userId: auth.userId,
+                },
+                userUrl: `${userUrl}/login/`,
+            });
+        });
+    });
+    describe('ledgerApi', () => {
+        it('performs GET via ledger client', async () => {
+            ledgerMocks.getWithRetry.mockResolvedValueOnce({ ok: true });
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.ledgerApi({
+                requestMethod: 'get',
+                resource: '/v2/parties',
+                path: { partyId: 'party::x' },
+                query: { limit: '10' },
+            });
+            expect(ledgerMocks.getWithRetry).toHaveBeenCalledWith('/v2/parties', undefined, {
+                path: { partyId: 'party::x' },
+                query: { limit: '10' },
+            });
+            expect(result).toEqual({ ok: true });
+        });
+        it('performs POST via ledger client', async () => {
+            ledgerMocks.postWithRetry.mockResolvedValueOnce({ created: true });
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.ledgerApi({
+                requestMethod: 'post',
+                resource: '/v2/commands/submit-and-wait',
+                body: { commands: [] },
+                query: { wait: 'true' },
+            });
+            expect(ledgerMocks.postWithRetry).toHaveBeenCalledWith('/v2/commands/submit-and-wait', { commands: [] }, undefined, { query: { wait: 'true' }, path: {} });
+            expect(result).toEqual({ created: true });
+        });
+        it('throws for unsupported request methods', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.ledgerApi({
+                requestMethod: 'patch',
+                resource: '/v2/parties',
+            })).rejects.toThrow('Unsupported request method: patch');
+        });
+        it('throws when auth context is missing', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.ledgerApi({
+                requestMethod: 'get',
+                resource: '/v2/parties',
+            })).rejects.toThrow();
+        });
+    });
+    describe('prepareExecute', () => {
+        const prepareParams = {
+            commands: [
+                {
+                    CreateCommand: {
+                        templateId: 'pkg:Mod:T',
+                        createArguments: {},
+                    },
+                },
+            ],
+        };
+        it('throws when auth context is missing', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.prepareExecute(prepareParams)).rejects.toThrow('Unauthenticated context');
+        });
+        it('throws when there is no primary wallet', async () => {
+            const store = await createStore(logger, auth, { withWallet: false });
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.prepareExecute(prepareParams)).rejects.toThrow('No primary wallet found');
+        });
+        it('prepares a transaction and returns the approve URL', async () => {
+            mockUuidV4.mockReturnValueOnce('generated-command-id');
+            mockUuidV4.mockReturnValueOnce('transaction-id');
+            ledgerMocks.postWithRetry.mockResolvedValueOnce({
+                preparedTransaction: 'prepared-blob',
+                preparedTransactionHash: 'hash',
+            });
+            const store = await createStore(logger, auth);
+            const setTransactionSpy = vi.spyOn(store, 'setTransaction');
+            const notifier = notificationService.getNotifier(auth.userId);
+            const emitSpy = vi.spyOn(notifier, 'emit');
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.prepareExecute(prepareParams);
+            expect(emitSpy).toHaveBeenCalledWith('txChanged', {
+                status: 'pending',
+                commandId: 'generated-command-id',
+            });
+            expect(ledgerMocks.postWithRetry).toHaveBeenCalledWith('/v2/interactive-submission/prepare', expect.any(Object));
+            expect(setTransactionSpy).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'transaction-id',
+                commandId: 'generated-command-id',
+                status: 'pending',
+                preparedTransaction: 'prepared-blob',
+                preparedTransactionHash: 'hash',
+                origin,
+            }));
+            expect(result.userUrl).toBe(`${userUrl}/approve/index.html?transactionId=transaction-id&commandId=generated-command-id&closeafteraction`);
+        });
+        it('uses the provided commandId when present', async () => {
+            mockUuidV4.mockReturnValueOnce('transaction-id');
+            ledgerMocks.postWithRetry.mockResolvedValueOnce({
+                preparedTransaction: 'prepared-blob',
+                preparedTransactionHash: 'hash',
+            });
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await controller.prepareExecute({
+                ...prepareParams,
+                commandId: 'existing-command-id',
+            });
+            expect(mockUuidV4).toHaveBeenCalledOnce();
+            expect(ledgerMocks.postWithRetry.mock.calls[0][1]).toMatchObject({
+                commandId: 'existing-command-id',
+            });
+        });
+        it('fetches synchronizerId from ledger when not on network', async () => {
+            const networkWithoutSync = {
+                ...storeNetwork,
+                synchronizerId: undefined,
+            };
+            const store = new StoreInternal({ idps: [idp], networks: [networkWithoutSync] }, logger, auth);
+            await store.setSession(session);
+            await store.addWallet(primaryWallet);
+            mockUuidV4.mockReturnValueOnce('cmd-id');
+            mockUuidV4.mockReturnValueOnce('tx-id');
+            ledgerMocks.postWithRetry.mockResolvedValueOnce({
+                preparedTransaction: 'blob',
+                preparedTransactionHash: 'hash',
+            });
+            const controller = createController(store, notificationService, logger, auth);
+            await controller.prepareExecute(prepareParams);
+            expect(ledgerMocks.getSynchronizerId).toHaveBeenCalled();
+        });
+    });
+    describe('signMessage', () => {
+        it('throws when message is missing', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.signMessage({ message: '' })).rejects.toThrow('Message is required');
+        });
+        it('throws when auth context is missing', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.signMessage({ message: 'hello' })).rejects.toThrow('Unauthenticated context');
+        });
+        it('throws when there is no primary wallet', async () => {
+            const store = await createStore(logger, auth, { withWallet: false });
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.signMessage({ message: 'hello' })).rejects.toThrow('No primary wallet found');
+        });
+        it('stores a pending message and returns the sign URL', async () => {
+            mockUuidV4.mockReturnValueOnce('message-id');
+            const store = await createStore(logger, auth);
+            const setMessageSpy = vi.spyOn(store, 'setMessageRaw');
+            const notifier = notificationService.getNotifier(auth.userId);
+            const emitSpy = vi.spyOn(notifier, 'emit');
+            const controller = createController(store, notificationService, logger, auth);
+            const result = await controller.signMessage({ message: 'hello' });
+            expect(setMessageSpy).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'message-id',
+                status: 'pending',
+                userId: auth.userId,
+                partyId: primaryWallet.partyId,
+                publicKey: primaryWallet.publicKey,
+                message: 'hello',
+                origin,
+            }));
+            expect(emitSpy).toHaveBeenCalledWith('messageSignature', {
+                status: 'pending',
+                messageId: 'message-id',
+            });
+            expect(result).toEqual({
+                messageId: 'message-id',
+                userUrl: `${userUrl}/sign-message/index.html?messageId=message-id&closeafteraction`,
+            });
+        });
+    });
+    describe('accounts', () => {
+        it('lists accounts from the store', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            const accounts = await controller.listAccounts();
+            expect(accounts).toHaveLength(1);
+            expect(accounts[0]?.partyId).toBe(primaryWallet.partyId);
+        });
+        it('returns the primary account', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.getPrimaryAccount()).resolves.toEqual(primaryWallet);
+        });
+        it('throws when there is no primary account', async () => {
+            const store = await createStore(logger, auth, { withWallet: false });
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.getPrimaryAccount()).rejects.toThrow('No primary wallet found');
+        });
+        it('returns the active network with access token when authenticated', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller.getActiveNetwork()).resolves.toEqual({
+                networkId: storeNetwork.id,
+                ledgerApi: storeNetwork.ledgerApi.baseUrl,
+                accessToken: auth.accessToken,
+            });
+        });
+        it('returns the active network without access token when unauthenticated', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, undefined);
+            await expect(controller.getActiveNetwork()).resolves.toEqual({
+                networkId: storeNetwork.id,
+                ledgerApi: storeNetwork.ledgerApi.baseUrl,
+            });
+        });
+    });
+    describe('event-only methods', () => {
+        it.each([
+            'connected',
+            'onStatusChanged',
+            'accountsChanged',
+            'txChanged',
+        ])('%s throws Only for events', async (method) => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            await expect(controller[method]()).rejects.toThrow('Only for events.');
+        });
+        it('messageSignature throws Only for events', async () => {
+            const store = await createStore(logger, auth);
+            const controller = createController(store, notificationService, logger, auth);
+            expect(() => controller.messageSignature()).toThrow('Only for events.');
+        });
+    });
+});

package/dist/dapp-api/rpc-gen/index.d.ts

@@ -12,6 +12,7 @@ import { AccountsChanged } from './typings.js';
 import { GetPrimaryAccount } from './typings.js';
 import { ListAccounts } from './typings.js';
 import { TxChanged } from './typings.js';
+import { MessageSignature } from './typings.js';
 export type Methods = {
     status: Status;
     connect: Connect;
@@ -27,6 +28,7 @@ export type Methods = {
     getPrimaryAccount: GetPrimaryAccount;
     listAccounts: ListAccounts;
     txChanged: TxChanged;
+    messageSignature: MessageSignature;
 };
 declare function buildController(methods: Methods): {
     status: Status;
@@ -43,6 +45,7 @@ declare function buildController(methods: Methods): {
     getPrimaryAccount: GetPrimaryAccount;
     listAccounts: ListAccounts;
     txChanged: TxChanged;
+    messageSignature: MessageSignature;
 };
 export default buildController;
 //# sourceMappingURL=index.d.ts.map

package/dist/dapp-api/rpc-gen/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dapp-api/rpc-gen/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,MAAM,MAAM,OAAO,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,WAAW,EAAE,WAAW,CAAA;IACxB,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,cAAc,EAAE,cAAc,CAAA;IAC9B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,SAAS,CAAA;IACpB,eAAe,EAAE,eAAe,CAAA;IAChC,eAAe,EAAE,eAAe,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,SAAS,CAAA;CACvB,CAAA;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;EAiBxC;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dapp-api/rpc-gen/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,MAAM,MAAM,OAAO,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,WAAW,EAAE,WAAW,CAAA;IACxB,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,cAAc,EAAE,cAAc,CAAA;IAC9B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,SAAS,CAAA;IACpB,eAAe,EAAE,eAAe,CAAA;IAChC,eAAe,EAAE,eAAe,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,SAAS,CAAA;IACpB,gBAAgB,EAAE,gBAAgB,CAAA;CACrC,CAAA;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;EAkBxC;AAED,eAAe,eAAe,CAAA"}

package/dist/dapp-api/rpc-gen/index.js

@@ -16,6 +16,7 @@ function buildController(methods) {
         getPrimaryAccount: methods.getPrimaryAccount,
         listAccounts: methods.listAccounts,
         txChanged: methods.txChanged,
+        messageSignature: methods.messageSignature,
     };
 }
 export default buildController;