@peers-app/peers-sdk 0.7.2 → 0.7.3

package/dist/data/user-trust-levels.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userTrustLevelSchema = void 0;
+exports.UserTrustLevels = UserTrustLevels;
+exports.getUserTrustLevel = getUserTrustLevel;
+exports.setUserTrustLevel = setUserTrustLevel;
+const zod_1 = require("zod");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const socket_type_1 = require("../device/socket.type");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+/**
+ * UserTrustLevels table allows different users/groups to assign their own trust levels
+ * to users without modifying the user's signed record.
+ *
+ * The trustLevel is scoped to the current DataContext (either user or group).
+ * Each context can maintain its own trust assessment of other users.
+ */
+exports.userTrustLevelSchema = zod_1.z.object({
+    userId: zod_1.z.string().describe('The user being assigned a trust level'),
+    trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel).describe('The trust level assigned to this user in this context'),
+    assignedAt: zod_1.z.date().optional().describe('When the trust level was assigned'),
+    notes: zod_1.z.string().optional().describe('Optional notes about why this trust level was assigned'),
+});
+const metaData = {
+    name: 'UserTrustLevels',
+    description: 'Trust levels assigned to users by the current context (user or group)',
+    primaryKeyName: 'userId',
+    fields: (0, types_1.schemaToFields)(exports.userTrustLevelSchema),
+    indexes: [
+        { fields: ['trustLevel'] },
+    ]
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userTrustLevelSchema);
+function UserTrustLevels(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.userTrustLevelSchema);
+}
+/**
+ * Get the trust level for a specific user in the given context.
+ * Returns TrustLevel.Unknown if no trust level has been assigned.
+ */
+async function getUserTrustLevel(dataContext, userId) {
+    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    if (dataContext === userContext.userDataContext && userContext.userId === userId) {
+        return socket_type_1.TrustLevel.Self;
+    }
+    const trustLevelRecord = await UserTrustLevels(dataContext).get(userId);
+    return trustLevelRecord?.trustLevel ?? socket_type_1.TrustLevel.Unknown;
+}
+/**
+ * Set the trust level for a specific user in the given context.
+ */
+async function setUserTrustLevel(userId, trustLevel, dataContext, notes) {
+    await UserTrustLevels(dataContext).save({
+        userId,
+        trustLevel,
+        assignedAt: new Date(),
+        notes,
+    });
+}

package/dist/data/users.d.ts

@@ -1,33 +1,33 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
-import { TrustLevel } from "../device/socket.type";
-import { ISaveOptions, Table } from "./orm";
+import type { ISaveOptions } from "./orm/data-query";
+import { Table } from "./orm/table";
 export declare const userSchema: z.ZodObject<{
     userId: z.ZodString;
     name: z.ZodString;
     publicKey: z.ZodString;
     publicBoxKey: z.ZodString;
-    trustLevel: z.ZodOptional<z.ZodNativeEnum<typeof TrustLevel>>;
     signature: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     publicKey: string;
-    publicBoxKey: string;
     userId: string;
+    publicBoxKey: string;
     signature?: string | undefined;
-    trustLevel?: TrustLevel | undefined;
 }, {
     name: string;
     publicKey: string;
-    publicBoxKey: string;
     userId: string;
+    publicBoxKey: string;
     signature?: string | undefined;
-    trustLevel?: TrustLevel | undefined;
 }>;
 export type IUser = z.infer<typeof userSchema>;
 export declare class UsersTable extends Table<IUser> {
     static isPassthrough: boolean;
     save(user: IUser, opts?: ISaveOptions): Promise<IUser>;
+    signAndSave(user: IUser, opts?: ISaveOptions): Promise<IUser>;
+    private static addSignatureToUser;
+    static enableUserSigning(fn: (user: IUser) => IUser): void;
     /** @deprecated Forbidden on UsersTable; use save() */
     insert(..._args: Parameters<Table<IUser>['insert']>): never;
     /** @deprecated Forbidden on UsersTable; use save() */

package/dist/data/users.js

@@ -1,22 +1,55 @@
 "use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.myUserId = exports.UsersTable = exports.userSchema = void 0;
 exports.Users = Users;
 exports.getMe = getMe;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
-const socket_type_1 = require("../device/socket.type");
-const orm_1 = require("./orm");
+const decorators_1 = require("./orm/decorators");
+const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
-const user_permissions_1 = require("./user-permissions");
 const persistent_vars_1 = require("./persistent-vars");
+const user_permissions_1 = require("./user-permissions");
 exports.userSchema = zod_1.z.object({
     userId: zod_1.z.string(),
     name: zod_1.z.string(),
     publicKey: zod_1.z.string().describe('The public key the user uses to sign messages'),
     publicBoxKey: zod_1.z.string().describe('The public key to use to encrypt data that only this user can decrypt'),
-    trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel).optional().describe('The trust level of the user'),
     signature: zod_1.z.string().optional().describe('The signed hash of this user object excluding the signature itself'),
 });
 const metaData = {
@@ -30,32 +63,58 @@ const metaData = {
         { fields: ['publicBoxKey'] },
     ]
 };
-class UsersTable extends orm_1.Table {
-    static isPassthrough = false;
-    async save(user, opts) {
-        if (UsersTable.isPassthrough) {
-            return super.save(user, opts);
+let UsersTable = (() => {
+    let _classSuper = table_1.Table;
+    let _instanceExtraInitializers = [];
+    let _signAndSave_decorators;
+    return class UsersTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _signAndSave_decorators = [(0, decorators_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _signAndSave_decorators, { kind: "method", name: "signAndSave", static: false, private: false, access: { has: obj => "signAndSave" in obj, get: obj => obj.signAndSave }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        const userContext = await (0, user_context_singleton_1.getUserContext)();
-        const userContextUserTable = Users(userContext.userDataContext);
-        if (this === userContextUserTable) {
-            // user is allowed to make any changes they want to their own user table
+        static isPassthrough = false;
+        async save(user, opts) {
+            if (UsersTable.isPassthrough) {
+                return super.save(user, opts);
+            }
+            const userContext = await (0, user_context_singleton_1.getUserContext)();
+            const userContextUserTable = Users(userContext.userDataContext);
+            if (this === userContextUserTable) {
+                // user is allowed to make any changes they want to their own user table
+                return super.save(user, opts);
+            }
+            // Get the old user record if it exists
+            const oldUser = await this.get(user.userId);
+            await (0, user_permissions_1.verifyUserSignature)(user, oldUser);
             return super.save(user, opts);
         }
-        // Get the old user record if it exists
-        const oldUser = await this.get(user.userId);
-        await (0, user_permissions_1.verifyUserSignature)(user, oldUser);
-        return super.save(user, opts);
-    }
-    /** @deprecated Forbidden on UsersTable; use save() */
-    insert(..._args) {
-        throw new Error('UsersTable forbids insert; use save()');
-    }
-    /** @deprecated Forbidden on UsersTable; use save() */
-    update(..._args) {
-        throw new Error('UsersTable forbids update; use save()');
-    }
-}
+        async signAndSave(user, opts) {
+            if (!UsersTable.addSignatureToUser) {
+                throw new Error('User signing must be enabled to sign and save users. Call UsersTable.enableUserSigning(fn) to enable it.');
+            }
+            user = UsersTable.addSignatureToUser(user);
+            return this.save(user, opts);
+        }
+        static addSignatureToUser = undefined;
+        static enableUserSigning(fn) {
+            UsersTable.addSignatureToUser = fn;
+        }
+        /** @deprecated Forbidden on UsersTable; use save() */
+        insert(..._args) {
+            throw new Error('UsersTable forbids insert; use save()');
+        }
+        /** @deprecated Forbidden on UsersTable; use save() */
+        update(..._args) {
+            throw new Error('UsersTable forbids update; use save()');
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
 exports.UsersTable = UsersTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userSchema, UsersTable);
 function Users(dataContext) {

package/dist/data/workflow-logs.d.ts

@@ -66,7 +66,7 @@ export declare const workflowLogSchema: z.ZodObject<{
     isError?: boolean | undefined;
 }>;
 export type IWorkflowLog = z.infer<typeof workflowLogSchema>;
-export declare function WorkflowLogs(dataContext?: DataContext): import("..").Table<{
+export declare function WorkflowLogs(dataContext?: DataContext): import("./orm").Table<{
     workflowLogId: string;
     workflowRunId: string;
     contextId: string;

package/dist/data/workflow-runs.js

@@ -93,7 +93,7 @@ let WorkflowRunTable = (() => {
     return class WorkflowRunTable extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _haltRun_decorators = [(0, orm_1.ProxyClientCalls)()];
+            _haltRun_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
             __esDecorate(this, null, _haltRun_decorators, { kind: "method", name: "haltRun", static: false, private: false, access: { has: obj => "haltRun" in obj, get: obj => obj.haltRun }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }

package/dist/data/workflows.d.ts

@@ -1,5 +1,5 @@
 import type { DataContext } from "../context/data-context";
-export declare function Workflows(dataContext?: DataContext): import("..").Table<{
+export declare function Workflows(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     description: string;
     createdAt: Date;

package/dist/device/get-trust-level.js

@@ -15,16 +15,17 @@ function getTrustLevelFn(me, serverUrl) {
             return socket_type_1.TrustLevel.Trusted;
         }
         // await Devices().delete(deviceInfo.deviceId);
-        let [user, device] = await Promise.all([
+        let [user, device, userTrustLevel] = await Promise.all([
             (0, data_1.Users)(userDataContext).get(deviceInfo.userId),
             (0, data_1.Devices)(userDataContext).get(deviceInfo.deviceId),
+            (0, data_1.UserTrustLevels)(userDataContext).get(deviceInfo.userId),
         ]);
         if (user && device && !(deviceInfo.userId === device.userId && deviceInfo.userId === user.userId && deviceInfo.publicKey === user.publicKey && deviceInfo.publicBoxKey === user.publicBoxKey)) {
             console.error(new Date().toISOString(), 'deviceInfo does not align with local info about user and device', { deviceInfo, user, device });
             // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
-        if (user?.trustLevel && user.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
+        if (userTrustLevel?.trustLevel && userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
             device.lastSeen = new Date();
             await (0, data_1.Devices)(userDataContext).update(device);
             return socket_type_1.TrustLevel.Trusted;
@@ -76,9 +77,12 @@ function getTrustLevelFn(me, serverUrl) {
         //     }
         //   }
         // }
-        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !user.trustLevel) {
-            user.trustLevel = socket_type_1.TrustLevel.Known;
-            await (0, data_1.Users)(userDataContext).save(user);
+        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !userTrustLevel) {
+            await (0, data_1.UserTrustLevels)(userDataContext).save({
+                userId: deviceInfo.userId,
+                trustLevel: socket_type_1.TrustLevel.Known,
+                assignedAt: new Date(),
+            });
         }
         else if (newUser) {
             await (0, data_1.Users)(userDataContext).save(user);

package/dist/rpc-types.d.ts

@@ -1,4 +1,3 @@
-import type { DataFilter, IDataQueryParams, ISaveOptions } from "./data/orm";
 export interface IEventData<T = any> {
     name: string;
     data: T;
@@ -17,16 +16,6 @@ export declare const rpcServerCalls: {
     setUserIdAndSecretKey: ((userId: string, secretKey: string) => Promise<void>);
     getUserId: () => Promise<string | undefined>;
     encryptData: ((value: string, groupId?: string) => Promise<string>);
-    tableGet: (dataContextId: string, tableName: string, id: string, opts?: {
-        useCache?: boolean;
-        cacheTtlMs?: number;
-    }) => Promise<any>;
-    tableList: ((dataContextId: string, tableName: string, filter?: DataFilter<any>, opts?: IDataQueryParams<any>) => Promise<any[]>);
-    tableCount: ((dataContextId: string, tableName: string, filter?: DataFilter<any>) => Promise<number>);
-    tableSave: ((dataContextId: string, tableName: string, record: any, opts?: ISaveOptions) => Promise<any>);
-    tableInsert: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
-    tableUpdate: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
-    tableDelete: ((dataContextId: string, tableName: string, recordOrId: any) => Promise<any>);
     tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
     resetAllDeviceSyncInfo: (() => Promise<void>);

package/dist/rpc-types.js

@@ -17,13 +17,6 @@ exports.rpcServerCalls = {
     getUserId: rpcStub('getUserId'),
     encryptData: rpcStub('encryptData'),
     // TODO collapse these all down to just tableMethodCall
-    tableGet: rpcStub('tableGet'),
-    tableList: rpcStub('tableList'),
-    tableCount: rpcStub('tableCount'),
-    tableSave: rpcStub('tableSave'),
-    tableInsert: rpcStub('tableInsert'),
-    tableUpdate: rpcStub('tableUpdate'),
-    tableDelete: rpcStub('tableDelete'),
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),

package/dist/users.query.d.ts

@@ -1,13 +1,15 @@
-import { DataContext, DataFilter, ICursorIterable, IUser } from "./index";
+import { DataContext, DataFilter, ICursorIterable, IUser, TrustLevel } from "./index";
 export interface IUsersQueryOpts {
     currentDataContext?: DataContext;
     includeCurrentDataContext?: boolean;
     includeUserDataContext?: boolean;
     includeOtherDataContexts?: boolean;
+    includeTrustLevel?: boolean;
 }
 export type IUserSource = 'currentDataContext' | 'userDataContext' | 'otherDataContexts';
 export interface IUserWithSource extends IUser {
     source: IUserSource;
+    trustLevel?: TrustLevel;
 }
 export declare function usersCursor(filter: DataFilter<IUser>, opts?: IUsersQueryOpts): Promise<ICursorIterable<IUserWithSource>>;
 export declare function getUserById(userId: string, opts?: IUsersQueryOpts): Promise<IUserWithSource | undefined>;

package/dist/users.query.js

@@ -4,7 +4,7 @@ exports.usersCursor = usersCursor;
 exports.getUserById = getUserById;
 const index_1 = require("./index");
 async function usersCursor(filter, opts = {}) {
-    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true, } = opts;
     const userContext = await (0, index_1.getUserContext)();
     const contextToUse = currentDataContext || userContext.defaultDataContext();
     let finalCursor = null;
@@ -13,10 +13,12 @@ async function usersCursor(filter, opts = {}) {
         const primaryTable = (0, index_1.Users)(contextToUse);
         const primarySource = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
         const primaryCursor = index_1.Cursor.fromDataSource(primaryTable, filter)
-            .map(user => {
+            .map(async (user) => {
+            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId) : undefined;
             const userWithSource = {
                 ...user,
                 source: primarySource,
+                trustLevel,
             };
             return userWithSource;
         });
@@ -26,10 +28,12 @@ async function usersCursor(filter, opts = {}) {
     if (includeUserDataContext && contextToUse !== userContext.userDataContext) {
         const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
         const userDataContextCursor = index_1.Cursor.fromDataSource(userDataContextTable, filter)
-            .map(user => {
+            .map(async (user) => {
+            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined;
             const userWithSource = {
                 ...user,
-                source: 'userDataContext'
+                source: 'userDataContext',
+                trustLevel,
             };
             return userWithSource;
         });
@@ -44,12 +48,26 @@ async function usersCursor(filter, opts = {}) {
             }
         }
         if (otherDataContexts.length > 0) {
+            // For trust levels from multiple contexts, we'll use the first context we find the user in
+            // This is a simplification - in reality, each group might have different trust levels
             const otherDataContextTables = otherDataContexts.map(dataContext => (0, index_1.Users)(dataContext));
             const otherDataContextsCursor = index_1.Cursor.fromDataSources(otherDataContextTables, filter)
-                .map(user => {
+                .map(async (user) => {
+                // Try to get trust level from the first group context that has this user
+                let trustLevel = undefined;
+                if (includeTrustLevel) {
+                    for (const dataContext of otherDataContexts) {
+                        const contextUser = await (0, index_1.Users)(dataContext).get(user.userId).catch(() => null);
+                        if (contextUser) {
+                            trustLevel = await (0, index_1.getUserTrustLevel)(dataContext, user.userId);
+                            break;
+                        }
+                    }
+                }
                 const userWithSource = {
                     ...user,
-                    source: 'otherDataContexts'
+                    source: 'otherDataContexts',
+                    trustLevel,
                 };
                 return userWithSource;
             });
@@ -59,7 +77,11 @@ async function usersCursor(filter, opts = {}) {
     // If no cursor was created, return empty cursor
     if (!finalCursor) {
         return index_1.Cursor.fromDataSource((0, index_1.Users)(contextToUse), { userId: { $eq: '__non_existent__' } })
-            .map(user => ({ ...user, source: 'userDataContext' }));
+            .map(async (user) => ({
+            ...user,
+            source: 'userDataContext',
+            trustLevel: includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined
+        }));
     }
     // Deduplication by userId
     // TODO: Push deduplication logic down into the queries for better performance
@@ -73,7 +95,7 @@ async function usersCursor(filter, opts = {}) {
     });
 }
 async function getUserById(userId, opts = {}) {
-    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true } = opts;
     const userContext = await (0, index_1.getUserContext)();
     const contextToUse = currentDataContext || userContext.defaultDataContext();
     // Try current data context first
@@ -83,9 +105,11 @@ async function getUserById(userId, opts = {}) {
             const user = await primaryTable.get(userId);
             if (user) {
                 const source = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
+                const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId) : undefined;
                 return {
                     ...user,
-                    source
+                    source,
+                    trustLevel,
                 };
             }
         }
@@ -99,9 +123,11 @@ async function getUserById(userId, opts = {}) {
             const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
             const user = await userDataContextTable.get(userId);
             if (user) {
+                const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined;
                 return {
                     ...user,
-                    source: 'userDataContext'
+                    source: 'userDataContext',
+                    trustLevel,
                 };
             }
         }
@@ -117,9 +143,11 @@ async function getUserById(userId, opts = {}) {
                     const table = (0, index_1.Users)(dataContext);
                     const user = await table.get(userId);
                     if (user) {
+                        const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(dataContext, user.userId) : undefined;
                         return {
                             ...user,
-                            source: 'otherDataContexts'
+                            source: 'otherDataContexts',
+                            trustLevel,
                         };
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"