@canton-network/wallet-gateway-remote 0.1.0

package/dist/middleware/jwtAuth.d.ts

@@ -0,0 +1,5 @@
+import type { Request, Response, NextFunction } from 'express';
+import { AuthService } from '@canton-network/core-wallet-auth';
+import { Logger } from 'pino';
+export declare function jwtAuth(authService: AuthService, logger: Logger): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+//# sourceMappingURL=jwtAuth.d.ts.map

package/dist/middleware/jwtAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwtAuth.d.ts","sourceRoot":"","sources":["../../src/middleware/jwtAuth.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,wBAAgB,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,IAC9C,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,mBAehE"}

package/dist/middleware/jwtAuth.js

@@ -0,0 +1,20 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// middleware/jwtAuth.ts
+export function jwtAuth(authService, logger) {
+    return async (req, res, next) => {
+        const authHeader = req.headers.authorization;
+        try {
+            const context = await authService.verifyToken(authHeader);
+            req.authContext = context;
+            next();
+        }
+        catch (err) {
+            logger.warn({ err }, 'JWT verification failed');
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(401).json({
+                error: 'Invalid or expired token: ' + message,
+            });
+        }
+    };
+}

package/dist/middleware/rateLimit.d.ts

@@ -0,0 +1,2 @@
+export declare const rpcRateLimit: import("express-rate-limit").RateLimitRequestHandler;
+//# sourceMappingURL=rateLimit.d.ts.map

package/dist/middleware/rateLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimit.d.ts","sourceRoot":"","sources":["../../src/middleware/rateLimit.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,sDAKvB,CAAA"}

package/dist/middleware/rateLimit.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import rateLimit from 'express-rate-limit';
+export const rpcRateLimit = rateLimit({
+    windowMs: 1 * 60 * 1000, // 1 minute
+    max: 100, // limit each IP to 100 requests per windowMs
+    standardHeaders: true,
+    legacyHeaders: false,
+});

package/dist/notification/NotificationService.d.ts

@@ -0,0 +1,11 @@
+type EventListener = (...args: unknown[]) => void;
+export interface Notifier {
+    on(event: string, listener: EventListener): void;
+    emit(event: string, ...args: unknown[]): boolean;
+    removeListener(event: string, listenerToRemove: EventListener): void;
+}
+export interface NotificationService {
+    getNotifier(notifierId: string): Notifier;
+}
+export {};
+//# sourceMappingURL=NotificationService.d.ts.map

package/dist/notification/NotificationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationService.d.ts","sourceRoot":"","sources":["../../src/notification/NotificationService.ts"],"names":[],"mappings":"AAKA,KAAK,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;AACjD,MAAM,WAAW,QAAQ;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAA;IAEhD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;IAEhD,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,GAAG,IAAI,CAAA;CACvE;AAED,MAAM,WAAW,mBAAmB;IAChC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAA;CAC5C"}

package/dist/notification/NotificationService.js

@@ -0,0 +1,5 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// TODO: make events type-of dApp methods (perhaps just )
+// Support event-driven notifications. We represent a notifier with a generic interface to support node and browser implementations.
+export {};

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

@@ -0,0 +1,23 @@
+import { Store } from '@canton-network/core-wallet-store';
+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, store: Store, notificationService: NotificationService, authContext: AuthContext | undefined, drivers: AvailableSigningDrivers, _logger: Logger) => {
+    addNetwork: import("./rpc-gen/typings.js").AddNetwork;
+    removeNetwork: import("./rpc-gen/typings.js").RemoveNetwork;
+    createWallet: import("./rpc-gen/typings.js").CreateWallet;
+    setPrimaryWallet: import("./rpc-gen/typings.js").SetPrimaryWallet;
+    removeWallet: import("./rpc-gen/typings.js").RemoveWallet;
+    listWallets: import("./rpc-gen/typings.js").ListWallets;
+    syncWallets: import("./rpc-gen/typings.js").SyncWallets;
+    sign: import("./rpc-gen/typings.js").Sign;
+    execute: import("./rpc-gen/typings.js").Execute;
+    listNetworks: import("./rpc-gen/typings.js").ListNetworks;
+    addSession: import("./rpc-gen/typings.js").AddSession;
+    listSessions: import("./rpc-gen/typings.js").ListSessions;
+};
+export {};
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/user-api/controller.ts"],"names":[],"mappings":"AAkBA,OAAO,EACH,KAAK,EAIR,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAEH,WAAW,EAEd,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EACH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AAOzC,KAAK,uBAAuB,GAAG,OAAO,CAClC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,cAAc,GACvB,YAAY,UAAU,EACtB,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,GAAG,SAAS,EACpC,SAAS,uBAAuB,EAChC,SAAS,MAAM;;;;;;;;;;;;;CAiclB,CAAA"}

package/dist/user-api/controller.js

@@ -0,0 +1,336 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Disabled unused vars rule to allow for future implementations
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { LedgerClient } from '@canton-network/core-ledger-client';
+import buildController from './rpc-gen/index.js';
+import { assertConnected, clientCredentialsService, } from '@canton-network/core-wallet-auth';
+import { SigningProvider, } from '@canton-network/core-signing-lib';
+import { PartyAllocationService, } from '../ledger/party-allocation-service.js';
+import { WalletSyncService } from '../ledger/wallet-sync-service.js';
+export const userController = (kernelInfo, store, notificationService, authContext, drivers, _logger) => {
+    const logger = _logger.child({ component: 'user-controller' });
+    return buildController({
+        addNetwork: async (params) => {
+            const { network } = params;
+            const ledgerApi = {
+                baseUrl: network.ledgerApi ?? '',
+            };
+            let auth;
+            if (network.auth.type === 'implicit') {
+                auth = {
+                    type: 'implicit',
+                    identityProviderId: network.auth.identityProviderId,
+                    issuer: network.auth.issuer ?? '',
+                    configUrl: network.auth.configUrl ?? '',
+                    audience: network.auth.audience ?? '',
+                    scope: network.auth.scope ?? '',
+                    clientId: network.auth.clientId ?? '',
+                };
+            }
+            else {
+                auth = {
+                    type: 'password',
+                    identityProviderId: network.auth.identityProviderId,
+                    issuer: network.auth.issuer ?? '',
+                    configUrl: network.auth.configUrl ?? '',
+                    tokenUrl: network.auth.tokenUrl ?? '',
+                    grantType: network.auth.grantType ?? '',
+                    scope: network.auth.scope ?? '',
+                    clientId: network.auth.clientId ?? '',
+                    audience: network.auth.audience ?? '',
+                };
+            }
+            const newNetwork = {
+                name: network.name,
+                chainId: network.chainId,
+                description: network.description,
+                synchronizerId: network.synchronizerId,
+                auth,
+                ledgerApi,
+            };
+            // TODO: Add an explicit updateNetwork method to the User API spec and controller
+            const existingNetworks = await store.listNetworks();
+            if (existingNetworks.find((n) => n.chainId === newNetwork.chainId)) {
+                await store.updateNetwork(newNetwork);
+            }
+            else {
+                await store.addNetwork(newNetwork);
+            }
+            return null;
+        },
+        removeNetwork: async (params) => {
+            await store.removeNetwork(params.networkName);
+            return null;
+        },
+        createWallet: async (params) => {
+            logger.info(`Allocating party with params: ${JSON.stringify(params)}`);
+            const userId = assertConnected(authContext);
+            const notifier = notificationService.getNotifier(userId);
+            const network = await store.getCurrentNetwork();
+            if (network === undefined) {
+                throw new Error('No network session found');
+            }
+            const adminToken = await clientCredentialsService(network.auth.configUrl, logger).fetchToken({
+                clientId: network.auth.admin.clientId,
+                clientSecret: network.auth.admin.clientSecret,
+                scope: network.auth.scope,
+                audience: network.auth.audience,
+            });
+            logger.debug({ adminToken }, 'Fetched admin token for party allocation');
+            const partyAllocator = new PartyAllocationService(network.synchronizerId, adminToken, network.ledgerApi.baseUrl, logger);
+            const driver = drivers[params.signingProviderId]?.controller(userId);
+            if (!driver) {
+                throw new Error(`Signing provider ${params.signingProviderId} not supported`);
+            }
+            let party;
+            let publicKey;
+            switch (params.signingProviderId) {
+                case SigningProvider.PARTICIPANT: {
+                    party = await partyAllocator.allocateParty(userId, params.partyHint);
+                    break;
+                }
+                case SigningProvider.WALLET_KERNEL: {
+                    const key = await driver.createKey({
+                        name: params.partyHint,
+                    });
+                    party = await partyAllocator.allocateParty(userId, params.partyHint, key.publicKey, async (hash) => {
+                        const { signature } = await driver.signTransaction({
+                            tx: '',
+                            txHash: hash,
+                            publicKey: key.publicKey,
+                        });
+                        return signature;
+                    });
+                    publicKey = key.publicKey;
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported signing provider: ${params.signingProviderId}`);
+            }
+            const wallet = {
+                signingProviderId: params.signingProviderId,
+                chainId: params.chainId,
+                primary: params.primary ?? false,
+                publicKey: publicKey || party.namespace,
+                ...party,
+            };
+            await store.addWallet(wallet);
+            const wallets = await store.getWallets();
+            notifier?.emit('accountsChanged', wallets);
+            return { wallet };
+        },
+        setPrimaryWallet: async (params) => {
+            store.setPrimaryWallet(params.partyId);
+            const notifier = authContext?.userId
+                ? notificationService.getNotifier(authContext.userId)
+                : undefined;
+            notifier?.emit('accountsChanged', await store.getWallets());
+            return null;
+        },
+        removeWallet: async (params) => Promise.resolve({}),
+        listWallets: async (params) => {
+            // TODO: support filters
+            return store.getWallets();
+        },
+        sign: async ({ preparedTransaction, preparedTransactionHash, partyId, commandId, }) => {
+            const wallets = await store.getWallets();
+            const wallet = wallets.find((w) => w.partyId === partyId);
+            const network = await store.getCurrentNetwork();
+            if (wallet === undefined) {
+                throw new Error('No primary wallet found');
+            }
+            const userId = assertConnected(authContext);
+            if (network === undefined) {
+                throw new Error('No network session found');
+            }
+            const notifier = notificationService.getNotifier(userId);
+            const signingProvider = wallet.signingProviderId;
+            const driver = drivers[signingProvider]?.controller(userId);
+            if (!driver) {
+                throw new Error('No driver found for WALLET_KERNEL');
+            }
+            switch (wallet.signingProviderId) {
+                case SigningProvider.PARTICIPANT: {
+                    return {
+                        signature: 'none',
+                        signedBy: wallet.namespace,
+                        partyId,
+                    };
+                }
+                case SigningProvider.WALLET_KERNEL: {
+                    const signature = await driver.signTransaction({
+                        tx: preparedTransaction,
+                        txHash: preparedTransactionHash,
+                        publicKey: wallet.publicKey,
+                    });
+                    if (!signature.signature) {
+                        throw new Error('Failed to sign transaction: ' +
+                            JSON.stringify(signature));
+                    }
+                    const signedTx = {
+                        commandId,
+                        status: 'signed',
+                        preparedTransaction,
+                        preparedTransactionHash,
+                    };
+                    store.setTransaction(signedTx);
+                    notifier.emit('txChanged', signedTx);
+                    return {
+                        signature: signature.signature,
+                        signedBy: wallet.namespace,
+                        partyId: wallet.partyId,
+                    };
+                }
+                default:
+                    throw new Error(`Unsupported signing provider: ${wallet.signingProviderId}`);
+            }
+        },
+        execute: async ({ commandId, signature, signedBy, partyId, }) => {
+            const wallet = await store.getPrimaryWallet();
+            const network = await store.getCurrentNetwork();
+            const transaction = await store.getTransaction(commandId);
+            if (wallet === undefined) {
+                throw new Error('No primary wallet found');
+            }
+            if (transaction === undefined) {
+                throw new Error('No transaction found');
+            }
+            const userId = assertConnected(authContext);
+            if (network === undefined) {
+                throw new Error('No network session found');
+            }
+            const notifier = notificationService.getNotifier(userId);
+            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), authContext.accessToken, logger);
+            switch (wallet.signingProviderId) {
+                case SigningProvider.PARTICIPANT: {
+                    // Participant signing provider specific logic can be added here
+                    const request = {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- because OpenRPC codegen type is incompatible with ledger codegen type
+                        commands: transaction?.payload,
+                        commandId,
+                        userId,
+                        actAs: [partyId],
+                        readAs: [],
+                        disclosedContracts: [],
+                        synchronizerId: network.synchronizerId,
+                        packageIdSelectionPreference: [],
+                    };
+                    try {
+                        const res = await ledgerClient.post('/v2/commands/submit-and-wait', request);
+                        notifier.emit('txChanged', {
+                            status: 'executed',
+                            commandId,
+                            payload: res,
+                        });
+                        return res;
+                    }
+                    catch (error) {
+                        throw new Error('Failed to submit transaction: ' + error);
+                    }
+                }
+                case SigningProvider.WALLET_KERNEL: {
+                    const result = await ledgerClient.post('/v2/interactive-submission/execute', {
+                        userId,
+                        preparedTransaction: transaction.preparedTransaction,
+                        hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',
+                        submissionId: commandId,
+                        deduplicationPeriod: {
+                            Empty: {},
+                        },
+                        partySignatures: {
+                            signatures: [
+                                {
+                                    party: partyId,
+                                    signatures: [
+                                        {
+                                            signature,
+                                            signedBy,
+                                            format: 'SIGNATURE_FORMAT_CONCAT',
+                                            signingAlgorithmSpec: 'SIGNING_ALGORITHM_SPEC_ED25519',
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    });
+                    const signedTx = {
+                        commandId,
+                        status: 'executed',
+                        preparedTransaction: transaction.preparedTransaction,
+                        preparedTransactionHash: transaction.preparedTransactionHash,
+                        payload: result,
+                    };
+                    store.setTransaction(signedTx);
+                    notifier.emit('txChanged', signedTx);
+                    return result;
+                }
+                default:
+                    throw new Error(`Unsupported signing provider: ${wallet.signingProviderId}`);
+            }
+        },
+        listNetworks: async () => Promise.resolve({ networks: await store.listNetworks() }),
+        addSession: async function (params) {
+            try {
+                await store.setSession({
+                    network: params.chainId,
+                    accessToken: authContext?.accessToken || '',
+                });
+                const network = await store.getCurrentNetwork();
+                // Assumption: `setSession` calls `assertConnected`, so its safe to declare that the authContext is defined.
+                const { userId, accessToken } = authContext;
+                const notifier = notificationService.getNotifier(userId);
+                notifier.emit('onConnected', {
+                    kernel: kernelInfo,
+                    sessionToken: accessToken,
+                    chainId: network.chainId,
+                });
+                return Promise.resolve({
+                    accessToken,
+                    status: 'connected',
+                    network: {
+                        name: network.name,
+                        chainId: network.chainId,
+                        synchronizerId: network.synchronizerId,
+                        description: network.description,
+                        ledgerApi: network.ledgerApi,
+                        auth: network.auth,
+                    },
+                });
+            }
+            catch (error) {
+                logger.error(`Failed to add session: ${error}`);
+                throw new Error(`Failed to add session: ${error}`);
+            }
+        },
+        listSessions: async () => {
+            const session = await store.getSession();
+            if (!session) {
+                return { sessions: [] };
+            }
+            const network = await store.getNetwork(session.network);
+            return {
+                sessions: [
+                    {
+                        accessToken: authContext.accessToken,
+                        status: 'connected',
+                        network: {
+                            name: network.name,
+                            chainId: network.chainId,
+                            synchronizerId: network.synchronizerId,
+                            description: network.description,
+                            ledgerApi: network.ledgerApi,
+                            auth: network.auth,
+                        },
+                    },
+                ],
+            };
+        },
+        syncWallets: async function () {
+            const network = await store.getCurrentNetwork();
+            assertConnected(authContext);
+            const service = new WalletSyncService(store, new LedgerClient(new URL(network.ledgerApi.baseUrl), authContext.accessToken, logger), authContext, logger);
+            return await service.syncWallets();
+        },
+    });
+};

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

@@ -0,0 +1,42 @@
+import { AddNetwork } from './typings.js';
+import { RemoveNetwork } from './typings.js';
+import { CreateWallet } from './typings.js';
+import { SetPrimaryWallet } from './typings.js';
+import { RemoveWallet } from './typings.js';
+import { ListWallets } from './typings.js';
+import { SyncWallets } from './typings.js';
+import { Sign } from './typings.js';
+import { Execute } from './typings.js';
+import { ListNetworks } from './typings.js';
+import { AddSession } from './typings.js';
+import { ListSessions } from './typings.js';
+export type Methods = {
+    addNetwork: AddNetwork;
+    removeNetwork: RemoveNetwork;
+    createWallet: CreateWallet;
+    setPrimaryWallet: SetPrimaryWallet;
+    removeWallet: RemoveWallet;
+    listWallets: ListWallets;
+    syncWallets: SyncWallets;
+    sign: Sign;
+    execute: Execute;
+    listNetworks: ListNetworks;
+    addSession: AddSession;
+    listSessions: ListSessions;
+};
+declare function buildController(methods: Methods): {
+    addNetwork: AddNetwork;
+    removeNetwork: RemoveNetwork;
+    createWallet: CreateWallet;
+    setPrimaryWallet: SetPrimaryWallet;
+    removeWallet: RemoveWallet;
+    listWallets: ListWallets;
+    syncWallets: SyncWallets;
+    sign: Sign;
+    execute: Execute;
+    listNetworks: ListNetworks;
+    addSession: AddSession;
+    listSessions: ListSessions;
+};
+export default buildController;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/user-api/rpc-gen/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE3C,MAAM,MAAM,OAAO,GAAG;IAClB,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,aAAa,CAAA;IAC5B,YAAY,EAAE,YAAY,CAAA;IAC1B,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,YAAY,EAAE,YAAY,CAAA;IAC1B,WAAW,EAAE,WAAW,CAAA;IACxB,WAAW,EAAE,WAAW,CAAA;IACxB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,YAAY,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,YAAY,CAAA;CAC7B,CAAA;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;EAexC;AAED,eAAe,eAAe,CAAA"}

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

@@ -0,0 +1,19 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+function buildController(methods) {
+    return {
+        addNetwork: methods.addNetwork,
+        removeNetwork: methods.removeNetwork,
+        createWallet: methods.createWallet,
+        setPrimaryWallet: methods.setPrimaryWallet,
+        removeWallet: methods.removeWallet,
+        listWallets: methods.listWallets,
+        syncWallets: methods.syncWallets,
+        sign: methods.sign,
+        execute: methods.execute,
+        listNetworks: methods.listNetworks,
+        addSession: methods.addSession,
+        listSessions: methods.listSessions,
+    };
+}
+export default buildController;