@cityofzion/bs-multichain 1.0.15 → 1.1.0

package/dist/BSAggregator.d.ts

@@ -1,7 +1,7 @@
 import { TBSAccount, IBlockchainService, TUntilIndexRecord } from '@cityofzion/blockchain-service';
 export declare class BSAggregator<N extends string> {
-    #private;
     readonly blockchainServicesByName: Record<N, IBlockchainService<N>>;
+    readonly blockchainServices: IBlockchainService<N>[];
     constructor(blockchainServices: IBlockchainService<N>[]);
     validateAddressAllBlockchains(address: string): boolean;
     validateTextAllBlockchains(text: string): boolean;

package/dist/BSAggregator.js

@@ -8,60 +8,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _BSAggregator_blockchainServices;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSAggregator = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 class BSAggregator {
     constructor(blockchainServices) {
-        _BSAggregator_blockchainServices.set(this, void 0);
-        __classPrivateFieldSet(this, _BSAggregator_blockchainServices, blockchainServices, "f");
+        this.blockchainServices = blockchainServices;
         this.blockchainServicesByName = blockchainServices.reduce((acc, service) => {
             acc[service.name] = service;
             return acc;
         }, {});
     }
     validateAddressAllBlockchains(address) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateAddress(address));
+        return this.blockchainServices.some(bs => bs.validateAddress(address));
     }
     validateTextAllBlockchains(text) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => [bs.validateAddress(text), (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
+        return this.blockchainServices.some(bs => [bs.validateAddress(text), (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
     }
     validateKeyAllBlockchains(wif) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateKey(wif));
+        return this.blockchainServices.some(bs => bs.validateKey(wif));
     }
     validateEncryptedAllBlockchains(keyOrJson) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson));
+        return this.blockchainServices.some(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson));
     }
     getBlockchainNameByAddress(address) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateAddress(address)).map(bs => bs.name);
+        return this.blockchainServices.filter(bs => bs.validateAddress(address)).map(bs => bs.name);
     }
     getBlockchainNameByKey(wif) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateKey(wif)).map(bs => bs.name);
+        return this.blockchainServices.filter(bs => bs.validateKey(wif)).map(bs => bs.name);
     }
     getBlockchainNameByEncrypted(keyOrJson) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f")
-            .filter(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson))
-            .map(bs => bs.name);
+        return this.blockchainServices.filter(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson)).map(bs => bs.name);
     }
     generateAccountsFromMnemonic(mnemonic, untilIndexByBlockchainService) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (0, blockchain_service_1.generateAccountForBlockchainService)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
+            return (0, blockchain_service_1.generateAccountForBlockchainService)(this.blockchainServices, (service, index) => __awaiter(this, void 0, void 0, function* () {
                 return service.generateAccountFromMnemonic(mnemonic, index);
             }), untilIndexByBlockchainService);
         });
     }
 }
 exports.BSAggregator = BSAggregator;
-_BSAggregator_blockchainServices = new WeakMap();

package/dist/features/wallet-connect/WalletKitHelper.d.ts

@@ -0,0 +1,17 @@
+import { ErrorResponse } from '@walletconnect/jsonrpc-utils';
+import type { PendingRequestTypes, SessionTypes } from '@walletconnect/types';
+import { SdkErrorKey } from '@walletconnect/utils';
+import { TWalletKitHelperFilterSessionsParams, TWalletKitHelperGetProposalDetailsParams, TWalletKitHelperGetSessionDetailsParams, TWalletKitHelperProcessRequestParams, TWalletKitHelperProposalDetails, TWalletKitHelperSessionDetails } from './types';
+export declare class WalletKitHelper {
+    static getProposalDetails<N extends string>({ address, proposal, services, }: TWalletKitHelperGetProposalDetailsParams<N>): TWalletKitHelperProposalDetails<N>;
+    static getSessionDetails<N extends string>({ session, services, }: TWalletKitHelperGetSessionDetailsParams<N>): TWalletKitHelperSessionDetails<N>;
+    static getError(key: SdkErrorKey): {
+        message: string;
+        code: number;
+    };
+    static formatRequestResult(request: PendingRequestTypes.Struct, response: any): import("@walletconnect/jsonrpc-utils").JsonRpcResult<any>;
+    static formatRequestError(request: PendingRequestTypes.Struct, reason: ErrorResponse): import("@walletconnect/jsonrpc-utils").JsonRpcError;
+    static processRequest<N extends string>({ sessionDetails, account, request, }: TWalletKitHelperProcessRequestParams<N>): Promise<any>;
+    static filterSessions(sessions: SessionTypes.Struct[], filters: TWalletKitHelperFilterSessionsParams): SessionTypes.Struct[];
+    static isValidURI(uri: string): boolean;
+}

package/dist/features/wallet-connect/WalletKitHelper.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletKitHelper = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const jsonrpc_utils_1 = require("@walletconnect/jsonrpc-utils");
+const utils_1 = require("@walletconnect/utils");
+class WalletKitHelper {
+    static getProposalDetails({ address, proposal, services, }) {
+        const mergedNamespacesObject = (0, utils_1.mergeRequiredAndOptionalNamespaces)(proposal.requiredNamespaces, proposal.optionalNamespaces);
+        const allChains = new Set((0, utils_1.getChainsFromRequiredNamespaces)(mergedNamespacesObject));
+        const service = services.find((service) => (0, blockchain_service_1.hasWalletConnect)(service) && allChains.has(service.walletConnectService.chain));
+        if (!service)
+            throw new blockchain_service_1.BSError('Requested chain(s) not supported by any service', 'NO_SERVICE');
+        const namespaceObject = mergedNamespacesObject[service.walletConnectService.namespace];
+        if (!namespaceObject)
+            throw new blockchain_service_1.BSError('Requested namespace not supported by any service', 'NO_SERVICE');
+        const approvedNamespaces = (0, utils_1.buildApprovedNamespaces)({
+            proposal: proposal,
+            supportedNamespaces: {
+                [service.walletConnectService.namespace]: {
+                    chains: [service.walletConnectService.chain],
+                    methods: service.walletConnectService.supportedMethods,
+                    events: service.walletConnectService.supportedEvents,
+                    accounts: [`${service.walletConnectService.chain}:${address}`],
+                },
+            },
+        });
+        const methods = namespaceObject.methods;
+        return { approvedNamespaces, methods, service, blockchain: service.name };
+    }
+    static getSessionDetails({ session, services, }) {
+        const sessionAccounts = (0, utils_1.getAccountsFromNamespaces)(session.namespaces);
+        const [sessionAddress] = (0, utils_1.getAddressesFromAccounts)(sessionAccounts);
+        if (!sessionAddress)
+            throw new blockchain_service_1.BSError('No accounts found in session', 'NO_ACCOUNTS');
+        const chains = (0, utils_1.getChainsFromNamespaces)(session.namespaces);
+        const service = services.find((service) => (0, blockchain_service_1.hasWalletConnect)(service) && chains.includes(service.walletConnectService.chain));
+        if (!service)
+            throw new blockchain_service_1.BSError('Requested chain not supported by any service', 'NO_SERVICE');
+        const methods = (0, utils_1.getNamespacesMethodsForChainId)(session.namespaces, service.walletConnectService.chain);
+        return { service, address: sessionAddress, methods, blockchain: service.name };
+    }
+    static getError(key) {
+        return (0, utils_1.getSdkError)(key);
+    }
+    static formatRequestResult(request, response) {
+        return (0, jsonrpc_utils_1.formatJsonRpcResult)(request.id, response);
+    }
+    static formatRequestError(request, reason) {
+        return (0, jsonrpc_utils_1.formatJsonRpcError)(request.id, reason !== null && reason !== void 0 ? reason : (0, utils_1.getSdkError)('USER_REJECTED'));
+    }
+    static processRequest(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sessionDetails, account, request, }) {
+            if (account.address !== sessionDetails.address) {
+                throw new blockchain_service_1.BSError('Account address does not match session address', 'INVALID_ACCOUNT');
+            }
+            const method = request.params.request.method;
+            if (!sessionDetails.methods.includes(method)) {
+                throw new blockchain_service_1.BSError('Method not supported by session', 'UNSUPPORTED_METHOD');
+            }
+            const serviceMethod = sessionDetails.service.walletConnectService[method];
+            if (!serviceMethod || typeof serviceMethod !== 'function')
+                throw new blockchain_service_1.BSError('Method not supported', 'UNSUPPORTED_METHOD');
+            const response = yield serviceMethod.apply(sessionDetails.service.walletConnectService, [
+                { account, params: request.params.request.params },
+            ]);
+            return response;
+        });
+    }
+    static filterSessions(sessions, filters) {
+        let filteredSessions = sessions;
+        if (filters === null || filters === void 0 ? void 0 : filters.addresses) {
+            filteredSessions = filteredSessions.filter(session => {
+                let matched = false;
+                if (filters.addresses) {
+                    const sessionAccounts = (0, utils_1.getAccountsFromNamespaces)(session.namespaces);
+                    const [address] = (0, utils_1.getAddressesFromAccounts)(sessionAccounts);
+                    if (address && filters.addresses.includes(address)) {
+                        matched = true;
+                    }
+                }
+                if (filters.chains && !matched) {
+                    const chains = (0, utils_1.getChainsFromNamespaces)(session.namespaces);
+                    if (chains.some(namespace => { var _a; return (_a = filters.chains) === null || _a === void 0 ? void 0 : _a.includes(namespace); })) {
+                        matched = true;
+                    }
+                }
+                return matched;
+            });
+        }
+        return filteredSessions;
+    }
+    static isValidURI(uri) {
+        return /^wc:.+@\d.*$/g.test(uri);
+    }
+}
+exports.WalletKitHelper = WalletKitHelper;

package/dist/features/wallet-connect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './WalletKitHelper';
+export * from './types';

package/dist/features/wallet-connect/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./WalletKitHelper"), exports);
+__exportStar(require("./types"), exports);

package/dist/features/wallet-connect/types.d.ts

@@ -0,0 +1,32 @@
+import { IBlockchainService, IBSWithWalletConnect, TBSAccount } from '@cityofzion/blockchain-service';
+import { PendingRequestTypes, ProposalTypes, SessionTypes } from '@walletconnect/types';
+export type TWalletKitHelperGetProposalDetailsParams<N extends string = string> = {
+    proposal: ProposalTypes.Struct;
+    address: string;
+    services: IBlockchainService<N>[];
+};
+export type TWalletKitHelperProposalDetails<N extends string = string> = {
+    methods: string[];
+    approvedNamespaces: SessionTypes.Namespaces;
+    service: IBlockchainService<N> & IBSWithWalletConnect;
+    blockchain: N;
+};
+export type TWalletKitHelperGetSessionDetailsParams<N extends string = string> = {
+    session: SessionTypes.Struct;
+    services: IBlockchainService<N>[];
+};
+export type TWalletKitHelperSessionDetails<N extends string = string> = {
+    address: string;
+    methods: string[];
+    service: IBlockchainService<N> & IBSWithWalletConnect;
+    blockchain: N;
+};
+export type TWalletKitHelperProcessRequestParams<N extends string = string> = {
+    request: PendingRequestTypes.Struct;
+    sessionDetails: TWalletKitHelperSessionDetails<N>;
+    account: TBSAccount<N>;
+};
+export type TWalletKitHelperFilterSessionsParams = {
+    addresses?: string[];
+    chains?: string[];
+};

package/dist/features/wallet-connect/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './features/swap';
 export * from './features/bridge';
+export * from './features/wallet-connect';
 export * from './BSAggregator';

package/dist/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./features/swap"), exports);
 __exportStar(require("./features/bridge"), exports);
+__exportStar(require("./features/wallet-connect"), exports);
 __exportStar(require("./BSAggregator"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-multichain",
-  "version": "1.0.15",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -11,11 +11,14 @@
   ],
   "dependencies": {
     "axios": "~1.12.2",
-    "@cityofzion/blockchain-service": "1.21.3"
+    "@walletconnect/utils": "~2.21.9",
+    "@walletconnect/jsonrpc-utils": "~1.0.8",
+    "@cityofzion/blockchain-service": "1.22.0"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
     "@types/jest": "~30.0.0",
+    "@walletconnect/types": "~2.21.9",
     "dotenv": "~17.2.2",
     "eslint": "~9.36.0",
     "jest": "~30.1.3",
@@ -23,10 +26,10 @@
     "ts-node": "~10.9.2",
     "typescript": "~5.9.2",
     "typed-emitter": "~2.1.0",
-    "@cityofzion/bs-ethereum": "2.13.5",
+    "@cityofzion/bs-ethereum": "2.14.0",
+    "@cityofzion/bs-neo3": "1.17.0",
     "@cityofzion/bs-neo-legacy": "1.13.5",
-    "@cityofzion/bs-neox": "1.3.6",
-    "@cityofzion/bs-neo3": "1.16.4"
+    "@cityofzion/bs-neox": "1.4.0"
   },
   "scripts": {
     "build": "rm -rf ./dist && tsc --project tsconfig.build.json",