@canton-network/wallet-gateway-remote 0.17.3 → 0.19.0

package/README.md

@@ -51,3 +51,40 @@ The JSON-RPC API specs from `api-specs/` are generated into strongly-typed metho
 2. Place the `fireblocks_secret.key` file at the path `/splice-wallet-kernel/wallet-gateway/remote`
 
 3. Create a file named `fireblocks_api.key` at the path `/splice-wallet-kernel/wallet-gateway/remote` and insert your Fireblocks API key into it (get it from `API User (ID)` column in fireblocks api users table). Make sure file doesn't end with new line character.
+
+## Postgres connection
+
+To create a Postgres database you need to:
+
+1. Start Postgres in Docker using:
+
+```shell
+$ docker run --network=host --name some-postgres -e POSTGRES_PASSWORD=postgres -d postgres
+```
+
+2. In the file `splice-wallet-kernel/wallet-gateway/test/config.json`, specify the connection settings for both databases (store and signingStore). The connection should look like this (it is important that `store.connection.database !== signingStore.connection.database !== 'postgres'`):
+
+```json
+{
+    "store": {
+        "connection": {
+            "type": "postgres",
+            "password": "postgres",
+            "port": 5432,
+            "user": "postgres",
+            "host": "0.0.0.0",
+            "database": "wallet_store"
+        }
+    },
+    "signingStore": {
+        "connection": {
+            "type": "postgres",
+            "password": "postgres",
+            "port": 5432,
+            "user": "postgres",
+            "host": "0.0.0.0",
+            "database": "signing_store"
+        }
+    }
+}
+```

package/dist/config/Config.d.ts

@@ -13,6 +13,7 @@ export declare const serverConfigSchema: z.ZodObject<{
     tls: z.ZodOptional<z.ZodBoolean>;
     requestSizeLimit: z.ZodDefault<z.ZodString>;
     requestRateLimit: z.ZodDefault<z.ZodNumber>;
+    admin: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const configSchema: z.ZodObject<{
     kernel: z.ZodObject<{
@@ -29,6 +30,7 @@ export declare const configSchema: z.ZodObject<{
         tls: z.ZodOptional<z.ZodBoolean>;
         requestSizeLimit: z.ZodDefault<z.ZodString>;
         requestRateLimit: z.ZodDefault<z.ZodNumber>;
+        admin: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     store: z.ZodObject<{
         connection: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -44,6 +46,23 @@ export declare const configSchema: z.ZodObject<{
             password: z.ZodString;
             database: z.ZodString;
         }, z.core.$strip>], "type">;
+    }, z.core.$strip>;
+    signingStore: z.ZodObject<{
+        connection: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"memory">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"sqlite">;
+            database: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"postgres">;
+            host: z.ZodString;
+            port: z.ZodNumber;
+            user: z.ZodString;
+            password: z.ZodString;
+            database: z.ZodString;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>;
+    bootstrap: z.ZodObject<{
         idps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             id: z.ZodString;
             type: z.ZodLiteral<"self_signed">;
@@ -103,21 +122,6 @@ export declare const configSchema: z.ZodObject<{
             }, z.core.$strip>], "method">>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
-    signingStore: z.ZodObject<{
-        connection: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"memory">;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"sqlite">;
-            database: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"postgres">;
-            host: z.ZodString;
-            port: z.ZodNumber;
-            user: z.ZodString;
-            password: z.ZodString;
-            database: z.ZodString;
-        }, z.core.$strip>], "type">;
-    }, z.core.$strip>;
 }, z.core.$strip>;
 export type KernelInfo = z.infer<typeof kernelInfoSchema>;
 export type ServerConfig = z.infer<typeof serverConfigSchema>;

package/dist/config/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;;;;iBAY3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;iBAsC7B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;;;;iBAY3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;iBA0C7B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/config/Config.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { storeConfigSchema } from '@canton-network/core-wallet-store';
+import { storeConfigSchema, bootstrapConfigSchema, } from '@canton-network/core-wallet-store';
 import { storeConfigSchema as signingStoreConfigSchema } from '@canton-network/core-signing-store-sql';
 import { z } from 'zod';
 export const kernelInfoSchema = z.object({
@@ -44,8 +44,11 @@ export const serverConfigSchema = z.object({
     requestSizeLimit: z.string().default('1mb').meta({
         description: 'The maximum size of incoming requests. Defaults to 1mb.',
     }),
-    requestRateLimit: z.number().default(100).meta({
-        description: 'The maximum number of requests per minute from a single IP address. Defaults to 100.',
+    requestRateLimit: z.number().default(10000).meta({
+        description: 'The maximum number of requests per minute from a single IP address. Defaults to 10000.',
+    }),
+    admin: z.string().optional().meta({
+        description: 'The JWT claim (e.g. "sub") identifying the admin user. If set, requests with a matching claim will be granted admin privileges.',
     }),
 });
 export const configSchema = z.object({
@@ -53,4 +56,5 @@ export const configSchema = z.object({
     server: z.preprocess((val) => val ?? {}, serverConfigSchema),
     store: storeConfigSchema,
     signingStore: signingStoreConfigSchema,
+    bootstrap: bootstrapConfigSchema,
 });

package/dist/config/Config.test.js

@@ -4,13 +4,13 @@ import { expect, test } from '@jest/globals';
 import { ConfigUtils } from './ConfigUtils.js';
 test('config from json file', async () => {
     const resp = ConfigUtils.loadConfigFile('../test/config.json');
-    expect(resp.store.networks[0].name).toBe('Local (OAuth IDP)');
-    expect(resp.store.networks[0].ledgerApi.baseUrl).toBe('http://127.0.0.1:5003');
-    expect(resp.store.networks[0].auth.clientId).toBe('operator');
-    expect(resp.store.networks[0].auth.scope).toBe('openid daml_ledger_api offline_access');
-    expect(resp.store.networks[0].auth.method).toBe('authorization_code');
-    expect(resp.store.networks[2].auth.method).toBe('client_credentials');
-    if (resp.store.networks[2].auth.method === 'client_credentials') {
-        expect(resp.store.networks[2].auth.audience).toBe('https://daml.com/jwt/aud/participant/participant1::1220d44fc1c3ba0b5bdf7b956ee71bc94ebe2d23258dc268fdf0824fbaeff2c61424');
+    expect(resp.bootstrap.networks[0].name).toBe('Local (OAuth IDP)');
+    expect(resp.bootstrap.networks[0].ledgerApi.baseUrl).toBe('http://127.0.0.1:5003');
+    expect(resp.bootstrap.networks[0].auth.clientId).toBe('operator');
+    expect(resp.bootstrap.networks[0].auth.scope).toBe('openid daml_ledger_api offline_access');
+    expect(resp.bootstrap.networks[0].auth.method).toBe('authorization_code');
+    expect(resp.bootstrap.networks[2].auth.method).toBe('client_credentials');
+    if (resp.bootstrap.networks[2].auth.method === 'client_credentials') {
+        expect(resp.bootstrap.networks[2].auth.audience).toBe('https://daml.com/jwt/aud/participant/participant1::1220d44fc1c3ba0b5bdf7b956ee71bc94ebe2d23258dc268fdf0824fbaeff2c61424');
     }
 });

package/dist/config/ConfigUtils.js

@@ -15,11 +15,11 @@ export class ConfigUtils {
              * 3. Each Network's identityProviderId maps to an existing IDP (in config)
              * 4. Each Network's auth method is compatible with its IDP type
              */
-            const duplicateIdpId = hasDuplicateElement(config.store.idps.map((idp) => idp.id));
+            const duplicateIdpId = hasDuplicateElement(config.bootstrap.idps.map((idp) => idp.id));
             if (duplicateIdpId) {
                 throw new Error(`Non-unique IDP IDs found in config file: ${duplicateIdpId}`);
             }
-            const duplicateNetworkId = hasDuplicateElement(config.store.networks.map((network) => network.id));
+            const duplicateNetworkId = hasDuplicateElement(config.bootstrap.networks.map((network) => network.id));
             if (duplicateNetworkId) {
                 throw new Error(`Non-unique Network IDs found in config file: ${duplicateNetworkId}`);
             }
@@ -48,8 +48,8 @@ function hasDuplicateElement(list) {
     return duplicate;
 }
 function validateNetworkToIdpMapping(config) {
-    for (const network of config.store.networks) {
-        const idp = config.store.idps.find((idp) => idp.id === network.identityProviderId);
+    for (const network of config.bootstrap.networks) {
+        const idp = config.bootstrap.idps.find((idp) => idp.id === network.identityProviderId);
         if (typeof idp === 'undefined') {
             return { networkId: network.id, idpId: network.identityProviderId };
         }
@@ -60,8 +60,8 @@ const SUPPORTED_IDP_METHODS = {
     oauth: ['authorization_code', 'client_credentials'],
 };
 function validateNetworkAuthMethods(config) {
-    for (const network of config.store.networks) {
-        const idp = config.store.idps.find((idp) => idp.id === network.identityProviderId);
+    for (const network of config.bootstrap.networks) {
+        const idp = config.bootstrap.idps.find((idp) => idp.id === network.identityProviderId);
         if (!SUPPORTED_IDP_METHODS[idp.type].includes(network.auth.method)) {
             return {
                 networkId: network.id,

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

@@ -7,14 +7,15 @@ export declare const dappController: (kernelInfo: KernelInfoConfig, dappUrl: str
     status: import("./rpc-gen/typings.js").Status;
     connect: import("./rpc-gen/typings.js").Connect;
     disconnect: import("./rpc-gen/typings.js").Disconnect;
-    darsAvailable: import("./rpc-gen/typings.js").DarsAvailable;
-    prepareReturn: import("./rpc-gen/typings.js").PrepareReturn;
+    getActiveNetwork: import("./rpc-gen/typings.js").GetActiveNetwork;
     prepareExecute: import("./rpc-gen/typings.js").PrepareExecute;
+    signMessage: import("./rpc-gen/typings.js").SignMessage;
     ledgerApi: import("./rpc-gen/typings.js").LedgerApi;
-    onConnected: import("./rpc-gen/typings.js").OnConnected;
+    connected: import("./rpc-gen/typings.js").Connected;
     onStatusChanged: import("./rpc-gen/typings.js").OnStatusChanged;
-    onAccountsChanged: import("./rpc-gen/typings.js").OnAccountsChanged;
-    requestAccounts: import("./rpc-gen/typings.js").RequestAccounts;
-    onTxChanged: import("./rpc-gen/typings.js").OnTxChanged;
+    accountsChanged: import("./rpc-gen/typings.js").AccountsChanged;
+    getPrimaryAccount: import("./rpc-gen/typings.js").GetPrimaryAccount;
+    listAccounts: import("./rpc-gen/typings.js").ListAccounts;
+    txChanged: import("./rpc-gen/typings.js").TxChanged;
 };
 //# sourceMappingURL=controller.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/dapp-api/controller.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAS/E,OAAO,EAAE,KAAK,EAAe,MAAM,mCAAmC,CAAA;AAQtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,eAAO,MAAM,cAAc,GACvB,YAAY,gBAAgB,EAC5B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,SAAS,MAAM,EACf,QAAQ,MAAM,GAAG,IAAI,EACrB,UAAU,WAAW;;;;;;;;;;;;;CAwPxB,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/dapp-api/controller.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAW/E,OAAO,EAAE,KAAK,EAAe,MAAM,mCAAmC,CAAA;AAQtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,eAAO,MAAM,cAAc,GACvB,YAAY,gBAAgB,EAC5B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,SAAS,MAAM,EACf,QAAQ,MAAM,GAAG,IAAI,EACrB,UAAU,WAAW;;;;;;;;;;;;;;CAwQxB,CAAA"}

package/dist/dapp-api/controller.js

@@ -11,14 +11,13 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
         connect: async () => {
             if (!context || !(await store.getSession())) {
                 return {
-                    kernel: kernelInfo,
                     isConnected: false,
                     isNetworkConnected: false,
                     networkReason: 'Unauthenticated',
                     userUrl: `${userUrl}/login/`,
                 };
             }
-            const session = await store.getSession();
+            // const session = await store.getSession()
             const network = await store.getCurrentNetwork();
             const ledgerClient = new LedgerClient({
                 baseUrl: new URL(network.ledgerApi.baseUrl),
@@ -27,24 +26,36 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                 accessToken: context.accessToken,
             });
             const status = await networkStatus(ledgerClient);
-            return {
-                kernel: kernelInfo,
+            const notifier = notificationService.getNotifier(context.userId);
+            const provider = {
+                id: kernelInfo.id,
+                version: 'TODO',
+                providerType: kernelInfo.clientType,
+                url: dappUrl,
+                userUrl: `${userUrl}/login/`,
+            };
+            const connection = {
                 isConnected: true,
+                reason: 'OK',
                 isNetworkConnected: status.isConnected,
                 networkReason: status.reason ? status.reason : 'OK',
+                userUrl: `${userUrl}/login/`,
+            };
+            const statusEvent = {
+                provider,
+                connection,
                 network: {
                     networkId: network.id,
-                    ledgerApi: {
-                        baseUrl: network.ledgerApi.baseUrl,
-                    },
+                    ledgerApi: network.ledgerApi.baseUrl,
+                    accessToken: context.accessToken,
                 },
                 session: {
-                    id: session?.id,
                     accessToken: context.accessToken,
                     userId: context.userId,
                 },
-                userUrl: `${userUrl}/login/`,
             };
+            notifier.emit('statusChanged', statusEvent);
+            return connection;
         },
         disconnect: async () => {
             if (!context) {
@@ -54,16 +65,22 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                 const notifier = notificationService.getNotifier(context.userId);
                 await store.removeSession();
                 notifier.emit('statusChanged', {
-                    kernel: kernelInfo,
-                    isConnected: false,
-                    isNetworkConnected: false,
-                    networkReason: 'Unauthenticated',
-                    userUrl: `${userUrl}/login/`,
+                    provider: {
+                        id: kernelInfo.id,
+                        providerType: kernelInfo.clientType,
+                        url: dappUrl,
+                        userUrl: `${userUrl}/login/`,
+                    },
+                    connection: {
+                        isConnected: false,
+                        reason: 'disconnect',
+                        isNetworkConnected: false,
+                        networkReason: 'disconnect',
+                    },
                 });
             }
             return null;
         },
-        darsAvailable: async () => ({ dars: ['default-dar'] }),
         ledgerApi: async (params) => {
             const network = await store.getCurrentNetwork();
             const ledgerClient = new LedgerClient({
@@ -135,33 +152,27 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             }, 'prepared transaction traffic estimation');
             store.setTransaction(transaction);
             return {
-                userUrl: `${userUrl}/approve/index.html?commandId=${commandId}`,
+                // closeafteraction query param flag makes approving or deleting tx close the popup
+                userUrl: `${userUrl}/approve/index.html?commandId=${commandId}&closeafteraction`,
             };
         },
-        prepareReturn: async (params) => {
-            const wallet = await store.getPrimaryWallet();
-            const network = await store.getCurrentNetwork();
-            if (context === undefined) {
-                throw new Error('Unauthenticated context');
-            }
-            if (wallet === undefined) {
-                throw new Error('No primary wallet found');
-            }
-            const ledgerClient = new LedgerClient({
-                baseUrl: new URL(network.ledgerApi.baseUrl),
-                logger,
-                isAdmin: false,
-                accessToken: context.accessToken,
-            });
-            return prepareSubmission(context.userId, wallet.partyId, network.synchronizerId, params, ledgerClient);
-        },
         status: async () => {
+            const provider = {
+                id: kernelInfo.id,
+                version: 'TODO',
+                providerType: kernelInfo.clientType,
+                url: dappUrl,
+                userUrl: `${userUrl}/login/`,
+            };
             if (!context || !(await store.getSession())) {
                 return {
-                    kernel: kernelInfo,
-                    isConnected: false,
-                    isNetworkConnected: false,
-                    networkReason: 'Unauthenticated',
+                    provider: provider,
+                    connection: {
+                        isConnected: false,
+                        reason: 'Unauthenticated',
+                        isNetworkConnected: false,
+                        networkReason: 'Unauthenticated',
+                    },
                 };
             }
             const session = await store.getSession();
@@ -174,15 +185,17 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             });
             const status = await networkStatus(ledgerClient);
             return {
-                kernel: kernelInfo,
-                isConnected: true,
-                isNetworkConnected: status.isConnected,
-                networkReason: status.reason ? status.reason : 'OK',
+                provider: provider,
+                connection: {
+                    isConnected: true,
+                    reason: 'OK',
+                    isNetworkConnected: status.isConnected,
+                    networkReason: status.reason ? status.reason : 'OK',
+                },
                 network: {
                     networkId: network.id,
-                    ledgerApi: {
-                        baseUrl: network.ledgerApi.baseUrl,
-                    },
+                    ledgerApi: network.ledgerApi.baseUrl,
+                    accessToken: context.accessToken,
                 },
                 session: {
                     id: session?.id,
@@ -192,22 +205,34 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                 userUrl: `${userUrl}/login/`,
             };
         },
-        onConnected: async () => {
+        connected: async () => {
             throw new Error('Only for events.');
         },
         onStatusChanged: async () => {
             throw new Error('Only for events.');
         },
-        onAccountsChanged: async () => {
+        accountsChanged: async () => {
             throw new Error('Only for events.');
         },
-        requestAccounts: async () => {
-            const wallets = await store.getWallets();
-            return wallets;
+        listAccounts: async () => {
+            return await store.getWallets();
         },
-        onTxChanged: async () => {
+        txChanged: async () => {
             throw new Error('Only for events.');
         },
+        getActiveNetwork: function () {
+            throw new Error('Function not implemented.');
+        },
+        signMessage: function () {
+            throw new Error('Function not implemented.');
+        },
+        getPrimaryAccount: async function () {
+            const wallet = await store.getPrimaryWallet();
+            if (!wallet) {
+                throw new Error('No primary wallet found');
+            }
+            return wallet;
+        },
     });
 };
 async function prepareSubmission(userId, partyId, synchronizerId, params, ledgerClient) {

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

@@ -1,42 +1,45 @@
 import { Status } from './typings.js';
 import { Connect } from './typings.js';
 import { Disconnect } from './typings.js';
-import { DarsAvailable } from './typings.js';
-import { PrepareReturn } from './typings.js';
+import { GetActiveNetwork } from './typings.js';
 import { PrepareExecute } from './typings.js';
+import { SignMessage } from './typings.js';
 import { LedgerApi } from './typings.js';
-import { OnConnected } from './typings.js';
+import { Connected } from './typings.js';
 import { OnStatusChanged } from './typings.js';
-import { OnAccountsChanged } from './typings.js';
-import { RequestAccounts } from './typings.js';
-import { OnTxChanged } from './typings.js';
+import { AccountsChanged } from './typings.js';
+import { GetPrimaryAccount } from './typings.js';
+import { ListAccounts } from './typings.js';
+import { TxChanged } from './typings.js';
 export type Methods = {
     status: Status;
     connect: Connect;
     disconnect: Disconnect;
-    darsAvailable: DarsAvailable;
-    prepareReturn: PrepareReturn;
+    getActiveNetwork: GetActiveNetwork;
     prepareExecute: PrepareExecute;
+    signMessage: SignMessage;
     ledgerApi: LedgerApi;
-    onConnected: OnConnected;
+    connected: Connected;
     onStatusChanged: OnStatusChanged;
-    onAccountsChanged: OnAccountsChanged;
-    requestAccounts: RequestAccounts;
-    onTxChanged: OnTxChanged;
+    accountsChanged: AccountsChanged;
+    getPrimaryAccount: GetPrimaryAccount;
+    listAccounts: ListAccounts;
+    txChanged: TxChanged;
 };
 declare function buildController(methods: Methods): {
     status: Status;
     connect: Connect;
     disconnect: Disconnect;
-    darsAvailable: DarsAvailable;
-    prepareReturn: PrepareReturn;
+    getActiveNetwork: GetActiveNetwork;
     prepareExecute: PrepareExecute;
+    signMessage: SignMessage;
     ledgerApi: LedgerApi;
-    onConnected: OnConnected;
+    connected: Connected;
     onStatusChanged: OnStatusChanged;
-    onAccountsChanged: OnAccountsChanged;
-    requestAccounts: RequestAccounts;
-    onTxChanged: OnTxChanged;
+    accountsChanged: AccountsChanged;
+    getPrimaryAccount: GetPrimaryAccount;
+    listAccounts: ListAccounts;
+    txChanged: TxChanged;
 };
 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,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE1C,MAAM,MAAM,OAAO,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,aAAa,CAAA;IAC5B,aAAa,EAAE,aAAa,CAAA;IAC5B,cAAc,EAAE,cAAc,CAAA;IAC9B,SAAS,EAAE,SAAS,CAAA;IACpB,WAAW,EAAE,WAAW,CAAA;IACxB,eAAe,EAAE,eAAe,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,eAAe,EAAE,eAAe,CAAA;IAChC,WAAW,EAAE,WAAW,CAAA;CAC3B,CAAA;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;EAexC;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,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,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;;;;;;;;;;;;;;EAgBxC;AAED,eAAe,eAAe,CAAA"}

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

@@ -5,15 +5,16 @@ function buildController(methods) {
         status: methods.status,
         connect: methods.connect,
         disconnect: methods.disconnect,
-        darsAvailable: methods.darsAvailable,
-        prepareReturn: methods.prepareReturn,
+        getActiveNetwork: methods.getActiveNetwork,
         prepareExecute: methods.prepareExecute,
+        signMessage: methods.signMessage,
         ledgerApi: methods.ledgerApi,
-        onConnected: methods.onConnected,
+        connected: methods.connected,
         onStatusChanged: methods.onStatusChanged,
-        onAccountsChanged: methods.onAccountsChanged,
-        requestAccounts: methods.requestAccounts,
-        onTxChanged: methods.onTxChanged,
+        accountsChanged: methods.accountsChanged,
+        getPrimaryAccount: methods.getPrimaryAccount,
+        listAccounts: methods.listAccounts,
+        txChanged: methods.txChanged,
     };
 }
 export default buildController;