@canton-network/core-wallet-store-inmemory 0.1.0

package/README.md

@@ -0,0 +1 @@
+# wallet-store

package/dist/Store.test.d.ts

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

package/dist/Store.test.d.ts.map

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

package/dist/Store.test.js

@@ -0,0 +1,158 @@
+import { beforeEach, describe, expect, test } from '@jest/globals';
+import { StoreInternal } from './StoreInternal';
+import { pino } from 'pino';
+import { sink } from 'pino-test';
+const authContextMock = {
+    userId: 'test-user-id',
+    accessToken: 'test-access-token',
+};
+const storeConfig = {
+    networks: [],
+};
+const implementations = [
+    ['StoreInternal', StoreInternal],
+];
+implementations.forEach(([name, StoreImpl]) => {
+    describe(name, () => {
+        let store;
+        beforeEach(() => {
+            store = new StoreImpl(storeConfig, pino(sink()), authContextMock);
+        });
+        test('should add and retrieve wallets', async () => {
+            const wallet = {
+                primary: false,
+                partyId: 'party1',
+                hint: 'hint',
+                signingProviderId: 'internal',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network1',
+            };
+            await store.addWallet(wallet);
+            const wallets = await store.getWallets();
+            expect(wallets).toHaveLength(1);
+        });
+        test('should filter wallets', async () => {
+            const wallet1 = {
+                primary: false,
+                partyId: 'party1',
+                hint: 'hint1',
+                signingProviderId: 'internal1',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network1',
+            };
+            const wallet2 = {
+                primary: false,
+                partyId: 'party2',
+                hint: 'hint2',
+                signingProviderId: 'internal2',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network1',
+            };
+            const wallet3 = {
+                primary: false,
+                partyId: 'party3',
+                hint: 'hint3',
+                signingProviderId: 'internal2',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network2',
+            };
+            await store.addWallet(wallet1);
+            await store.addWallet(wallet2);
+            await store.addWallet(wallet3);
+            const getAllWallets = await store.getWallets();
+            const getWalletsByChainId = await store.getWallets({
+                chainIds: ['network1'],
+            });
+            const getWalletsBySigningProviderId = await store.getWallets({
+                signingProviderIds: ['internal2'],
+            });
+            const getWalletsByChainIdAndSigningProviderId = await store.getWallets({
+                chainIds: ['network1'],
+                signingProviderIds: ['internal2'],
+            });
+            expect(getAllWallets).toHaveLength(3);
+            expect(getWalletsByChainId).toHaveLength(2);
+            expect(getWalletsBySigningProviderId).toHaveLength(2);
+            expect(getWalletsByChainIdAndSigningProviderId).toHaveLength(1);
+        });
+        test('should set and get primary wallet', async () => {
+            const wallet1 = {
+                primary: false,
+                partyId: 'party1',
+                hint: 'hint1',
+                signingProviderId: 'internal',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network1',
+            };
+            const wallet2 = {
+                primary: false,
+                partyId: 'party2',
+                hint: 'hint2',
+                signingProviderId: 'internal',
+                publicKey: 'publicKey',
+                namespace: 'namespace',
+                chainId: 'network1',
+            };
+            await store.addWallet(wallet1);
+            await store.addWallet(wallet2);
+            await store.setPrimaryWallet('party2');
+            const primary = await store.getPrimaryWallet();
+            expect(primary?.partyId).toBe('party2');
+            expect(primary?.primary).toBe(true);
+        });
+        test('should set and get session', async () => {
+            const session = { network: 'net', accessToken: 'token' };
+            await store.setSession(session);
+            const result = await store.getSession();
+            expect(result).toEqual(session);
+            await store.removeSession();
+            const removed = await store.getSession();
+            expect(removed).toBeUndefined();
+        });
+        test('should add, list, get, update, and remove networks', async () => {
+            const ledgerApi = {
+                baseUrl: 'http://api',
+                adminGrpcUrl: 'http://grpc',
+            };
+            const auth = {
+                identityProviderId: 'idp1',
+                type: 'password',
+                issuer: 'http://auth',
+                configUrl: 'http://auth/.well-known/openid-configuration',
+                tokenUrl: 'http://auth',
+                grantType: 'password',
+                clientId: 'cid',
+                scope: 'scope',
+                audience: 'aud',
+            };
+            const network = {
+                name: 'testnet',
+                chainId: 'network1',
+                synchronizerId: 'sync1::fingerprint',
+                description: 'Test Network',
+                ledgerApi,
+                auth,
+            };
+            await store.updateNetwork(network);
+            const listed = await store.listNetworks();
+            expect(listed).toHaveLength(1);
+            expect(listed[0].name).toBe('testnet');
+            const fetched = await store.getNetwork('network1');
+            expect(fetched.description).toBe('Test Network');
+            await store.removeNetwork('network1');
+            const afterRemove = await store.listNetworks();
+            expect(afterRemove).toHaveLength(0);
+        });
+        test('should throw when getting a non-existent network', async () => {
+            await expect(store.getNetwork('doesnotexist')).rejects.toThrow();
+        });
+        test('should throw when getting current network if none set', async () => {
+            await expect(store.getCurrentNetwork()).rejects.toThrow();
+        });
+    });
+});

package/dist/StoreInternal.d.ts

@@ -0,0 +1,42 @@
+import { Logger } from 'pino';
+import { AuthContext, UserId, AuthAware } from '@canton-network/core-wallet-auth';
+import { Store, Wallet, PartyId, Session, WalletFilter, Transaction, Network } from '@canton-network/core-wallet-store';
+interface UserStorage {
+    wallets: Array<Wallet>;
+    transactions: Map<string, Transaction>;
+    session: Session | undefined;
+}
+export interface StoreInternalConfig {
+    networks: Array<Network>;
+}
+type Memory = Map<UserId, UserStorage>;
+export declare class StoreInternal implements Store, AuthAware<StoreInternal> {
+    private logger;
+    private systemStorage;
+    private userStorage;
+    authContext: AuthContext | undefined;
+    constructor(config: StoreInternalConfig, logger: Logger, authContext?: AuthContext, userStorage?: Memory);
+    withAuthContext(context?: AuthContext): StoreInternal;
+    static createStorage(): UserStorage;
+    private assertConnected;
+    private getStorage;
+    private updateStorage;
+    private syncWallets;
+    getWallets(filter?: WalletFilter): Promise<Array<Wallet>>;
+    getPrimaryWallet(): Promise<Wallet | undefined>;
+    setPrimaryWallet(partyId: PartyId): Promise<void>;
+    addWallet(wallet: Wallet): Promise<void>;
+    getSession(): Promise<Session | undefined>;
+    setSession(session: Session): Promise<void>;
+    removeSession(): Promise<void>;
+    getNetwork(chainId: string): Promise<Network>;
+    getCurrentNetwork(): Promise<Network>;
+    listNetworks(): Promise<Array<Network>>;
+    updateNetwork(network: Network): Promise<void>;
+    addNetwork(network: Network): Promise<void>;
+    removeNetwork(chainId: string): Promise<void>;
+    setTransaction(transaction: Transaction): Promise<void>;
+    getTransaction(commandId: string): Promise<Transaction | undefined>;
+}
+export {};
+//# sourceMappingURL=StoreInternal.d.ts.map

package/dist/StoreInternal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreInternal.d.ts","sourceRoot":"","sources":["../src/StoreInternal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EACH,WAAW,EACX,MAAM,EACN,SAAS,EACZ,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACH,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,YAAY,EACZ,WAAW,EACX,OAAO,EACV,MAAM,mCAAmC,CAAA;AAG1C,UAAU,WAAW;IACjB,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACtC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAA;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;CAC3B;AAED,KAAK,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAGtC,qBAAa,aAAc,YAAW,KAAK,EAAE,SAAS,CAAC,aAAa,CAAC;IACjE,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,WAAW,CAAQ;IAE3B,WAAW,EAAE,WAAW,GAAG,SAAS,CAAA;gBAGhC,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,WAAW,EACzB,WAAW,CAAC,EAAE,MAAM;IAUxB,eAAe,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,aAAa;IASrD,MAAM,CAAC,aAAa,IAAI,WAAW;IAQnC,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,aAAa;YAOP,WAAW;IAqEnB,UAAU,CAAC,MAAM,GAAE,YAAiB,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAkB7D,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAK/C,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBxC,UAAU,IAAI,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;IAI1C,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3C,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAW7C,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAkBrC,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAIvC,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9C,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3C,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7C,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAQvD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;CAM5E"}

package/dist/StoreInternal.js

@@ -0,0 +1,225 @@
+import { LedgerClient } from '@canton-network/core-ledger-client';
+// TODO: remove AuthAware and instead provide wrapper in clients
+export class StoreInternal {
+    logger;
+    systemStorage;
+    userStorage;
+    authContext;
+    constructor(config, logger, authContext, userStorage) {
+        this.logger = logger.child({ component: 'StoreInternal' });
+        this.systemStorage = config;
+        this.authContext = authContext;
+        this.userStorage = userStorage || new Map();
+        this.syncWallets();
+    }
+    withAuthContext(context) {
+        return new StoreInternal(this.systemStorage, this.logger, context, this.userStorage);
+    }
+    static createStorage() {
+        return {
+            wallets: [],
+            transactions: new Map(),
+            session: undefined,
+        };
+    }
+    assertConnected() {
+        if (!this.authContext) {
+            throw new Error('User is not connected');
+        }
+        return this.authContext.userId;
+    }
+    getStorage() {
+        const userId = this.assertConnected();
+        if (!this.userStorage.has(userId)) {
+            this.userStorage.set(userId, StoreInternal.createStorage());
+        }
+        return this.userStorage.get(userId);
+    }
+    updateStorage(storage) {
+        const userId = this.assertConnected();
+        this.userStorage.set(userId, storage);
+    }
+    // Wallet methods
+    async syncWallets() {
+        try {
+            const network = await this.getCurrentNetwork();
+            // Get existing parties from participant
+            const ledgerClient = new LedgerClient(network.ledgerApi.baseUrl, this.authContext.accessToken, this.logger);
+            const rights = await ledgerClient.get('/v2/users/{user-id}/rights', {
+                path: {
+                    'user-id': this.authContext.userId,
+                },
+            });
+            const parties = rights.rights
+                ?.filter((right) => 'CanActAs' in right.kind)
+                .map((right) => {
+                if ('CanActAs' in right.kind) {
+                    return right.kind.CanActAs.value.party;
+                }
+                throw new Error('Unexpected right kind');
+            });
+            // Merge Wallets
+            const existingWallets = await this.getWallets();
+            const existingPartyIds = new Set(existingWallets.map((w) => w.partyId));
+            const participantWallets = parties
+                ?.filter((party) => !existingPartyIds.has(party)
+            // todo: filter on idp id
+            )
+                .map((party) => {
+                const [hint, namespace] = party.split('::');
+                return {
+                    primary: false,
+                    partyId: party,
+                    hint: hint,
+                    publicKey: namespace,
+                    namespace: namespace,
+                    chainId: network.chainId,
+                    signingProviderId: 'participant', // todo: determine based on partyDetails.isLocal
+                };
+            }) || [];
+            const storage = this.getStorage();
+            const wallets = [...storage.wallets, ...participantWallets];
+            // Set primary wallet if none exists
+            const hasPrimary = wallets.some((w) => w.primary);
+            if (!hasPrimary && wallets.length > 0) {
+                wallets[0].primary = true;
+            }
+            this.logger.debug(wallets, 'Wallets synchronized');
+            // Update storage with new wallets
+            storage.wallets = wallets;
+            this.updateStorage(storage);
+        }
+        catch {
+            return;
+        }
+    }
+    async getWallets(filter = {}) {
+        const { chainIds, signingProviderIds } = filter;
+        const chainIdSet = chainIds ? new Set(chainIds) : null;
+        const signingProviderIdSet = signingProviderIds
+            ? new Set(signingProviderIds)
+            : null;
+        return this.getStorage().wallets.filter((wallet) => {
+            const matchedChainIds = chainIdSet
+                ? chainIdSet.has(wallet.chainId)
+                : true;
+            const matchedStorageProviderIdS = signingProviderIdSet
+                ? signingProviderIdSet.has(wallet.signingProviderId)
+                : true;
+            return matchedChainIds && matchedStorageProviderIdS;
+        });
+    }
+    async getPrimaryWallet() {
+        const wallets = await this.getWallets();
+        return wallets.find((w) => w.primary === true);
+    }
+    async setPrimaryWallet(partyId) {
+        const storage = this.getStorage();
+        if (!storage.wallets.some((w) => w.partyId === partyId)) {
+            throw new Error(`Wallet with partyId "${partyId}" not found`);
+        }
+        const wallets = storage.wallets.map((w) => {
+            if (w.partyId === partyId) {
+                w.primary = true;
+            }
+            else {
+                w.primary = false;
+            }
+            return w;
+        });
+        storage.wallets = wallets;
+        this.updateStorage(storage);
+    }
+    async addWallet(wallet) {
+        const storage = this.getStorage();
+        if (storage.wallets.some((w) => w.partyId === wallet.partyId)) {
+            throw new Error(`Wallet with partyId "${wallet.partyId}" already exists`);
+        }
+        const wallets = await this.getWallets();
+        if (wallets.length === 0) {
+            // If this is the first wallet, set it as primary automatically
+            wallet.primary = true;
+        }
+        if (wallet.primary) {
+            // If the new wallet is primary, set all others to non-primary
+            storage.wallets.map((w) => (w.primary = false));
+        }
+        wallets.push(wallet);
+        storage.wallets = wallets;
+        this.updateStorage(storage);
+    }
+    // Session methods
+    async getSession() {
+        return this.getStorage().session;
+    }
+    async setSession(session) {
+        const storage = this.getStorage();
+        storage.session = session;
+        this.updateStorage(storage);
+    }
+    async removeSession() {
+        const storage = this.getStorage();
+        storage.session = undefined;
+        this.updateStorage(storage);
+    }
+    // Network methods
+    async getNetwork(chainId) {
+        this.assertConnected();
+        const networks = await this.listNetworks();
+        if (!networks)
+            throw new Error('No networks available');
+        const network = networks.find((n) => n.chainId === chainId);
+        if (!network)
+            throw new Error(`Network "${chainId}" not found`);
+        return network;
+    }
+    async getCurrentNetwork() {
+        const session = this.getStorage().session;
+        if (!session) {
+            throw new Error('No session found');
+        }
+        const chainId = session.network;
+        if (!chainId) {
+            throw new Error('No current network set in session');
+        }
+        const networks = await this.listNetworks();
+        const network = networks.find((n) => n.chainId === chainId);
+        if (!network) {
+            throw new Error(`Network "${chainId}" not found`);
+        }
+        return network;
+    }
+    async listNetworks() {
+        return this.systemStorage.networks;
+    }
+    async updateNetwork(network) {
+        this.assertConnected();
+        this.removeNetwork(network.chainId); // Ensure no duplicates
+        this.systemStorage.networks.push(network);
+    }
+    async addNetwork(network) {
+        const networkAlreadyExists = this.systemStorage.networks.find((n) => n.chainId === network.chainId);
+        if (networkAlreadyExists) {
+            throw new Error(`Network ${network.chainId} already exists`);
+        }
+        else {
+            this.systemStorage.networks.push(network);
+        }
+    }
+    async removeNetwork(chainId) {
+        this.assertConnected();
+        this.systemStorage.networks = this.systemStorage.networks.filter((n) => n.chainId !== chainId);
+    }
+    // Transaction methods
+    async setTransaction(transaction) {
+        this.assertConnected();
+        const storage = this.getStorage();
+        storage.transactions.set(transaction.commandId, transaction);
+        this.updateStorage(storage);
+    }
+    async getTransaction(commandId) {
+        this.assertConnected();
+        const storage = this.getStorage();
+        return storage.transactions.get(commandId);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './StoreInternal.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from './StoreInternal.js';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@canton-network/core-wallet-store-inmemory",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "In-memory implementation of the Store API",
+  "repository": "https://github.com/hyperledger-labs/splice-wallet-kernel",
+  "author": "Marc Juchli <marc.juchli@digitalasset.com>",
+  "license": "Apache-2.0",
+  "packageManager": "yarn@4.9.2",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "clean": "tsc -b --clean; rm -rf dist",
+    "test": "yarn node --experimental-vm-modules $(yarn bin jest)"
+  },
+  "dependencies": {
+    "@canton-network/core-ledger-client": "^0.1.0",
+    "@canton-network/core-wallet-auth": "^0.1.0",
+    "@canton-network/core-wallet-store": "^0.1.0",
+    "pino": "^9.7.0",
+    "zod": "^3.25.64"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.0.0",
+    "@swc/core": "^1.11.31",
+    "@swc/jest": "^0.2.38",
+    "@types/jest": "^30.0.0",
+    "jest": "^30.0.0",
+    "pino-test": "^1.1.0",
+    "ts-jest": "^29.4.0",
+    "ts-jest-resolver": "^2.0.1",
+    "typescript": "^5.8.3"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}