@decaf-ts/for-fabric 0.5.7 → 0.7.0

package/lib/cjs/contracts/ContractAdapter.cjs

@@ -0,0 +1,1193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricContractAdapter = void 0;
+exports.createdByOnFabricCreateUpdate = createdByOnFabricCreateUpdate;
+const for_couchdb_1 = require("@decaf-ts/for-couchdb");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const ContractContext_1 = require("./ContractContext.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const fabric_contract_api_1 = require("fabric-contract-api");
+const logging_1 = require("@decaf-ts/logging");
+const core_1 = require("@decaf-ts/core");
+const FabricContractRepository_1 = require("./FabricContractRepository.cjs");
+const FabricContractStatement_1 = require("./FabricContractStatement.cjs");
+const FabricContractSequence_1 = require("./FabricContractSequence.cjs");
+const constants_1 = require("./../shared/constants.cjs");
+const SimpleDeterministicSerializer_1 = require("./../shared/SimpleDeterministicSerializer.cjs");
+const decoration_1 = require("@decaf-ts/decoration");
+const FabricContractPaginator_1 = require("./FabricContractPaginator.cjs");
+const errors_1 = require("./../shared/errors.cjs");
+const FabricContractDispatch_1 = require("./FabricContractDispatch.cjs");
+/**
+ * @description Sets the creator or updater field in a model based on the user in the context
+ * @summary Callback function used in decorators to automatically set the created_by or updated_by fields
+ * with the username from the context when a document is created or updated
+ * @template M - Type extending Model
+ * @template R - Type extending NanoRepository<M>
+ * @template V - Type extending RelationsMetadata
+ * @param {R} this - The repository instance
+ * @param {FabricContractContext} context - The operation context containing user information
+ * @param {V} data - The relation metadata
+ * @param {string} key - The property key to set with the username
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function createdByOnFabricCreateUpdate
+ * @memberOf module:fabric.contracts
+ * @mermaid
+ * sequenceDiagram
+ *   participant F as createdByOnNanoCreateUpdate
+ *   participant C as Context
+ *   participant M as Model
+ *   F->>C: get("user")
+ *   C-->>F: user object
+ *   F->>M: set key to user.name
+ *   Note over F: If no user in context
+ *   F-->>F: throw UnsupportedError
+ */
+async function createdByOnFabricCreateUpdate(context, data, key, model) {
+    try {
+        const user = context.get("identity");
+        model[key] = user.getID();
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        throw new core_1.UnsupportedError("No User found in context. Please provide a user in the context");
+    }
+}
+/**
+ * @description Adapter for Hyperledger Fabric chaincode state database operations
+ * @summary Provides a CouchDB-like interface for interacting with the Fabric state database from within a chaincode contract
+ * @template void - No configuration needed for contract adapter
+ * @template FabricContractFlags - Flags specific to Fabric contract operations
+ * @template FabricContractContext - Context type for Fabric contract operations
+ * @class FabricContractAdapter
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract class
+ * import { FabricContractAdapter } from '@decaf-ts/for-fabric';
+ *
+ * export class MyContract extends Contract {
+ *   private adapter = new FabricContractAdapter();
+ *
+ *   @Transaction()
+ *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
+ *     const model = { id, data, timestamp: Date.now() };
+ *     await this.adapter.create('assets', id, model, {}, { stub: ctx.stub });
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Contract
+ *   participant FabricContractAdapter
+ *   participant Stub
+ *   participant StateDB
+ *
+ *   Contract->>FabricContractAdapter: create(tableName, id, model, transient, ctx)
+ *   FabricContractAdapter->>FabricContractAdapter: Serialize model to JSON
+ *   FabricContractAdapter->>Stub: putState(id, serializedData)
+ *   Stub->>StateDB: Write data
+ *   StateDB-->>Stub: Success
+ *   Stub-->>FabricContractAdapter: Success
+ *   FabricContractAdapter-->>Contract: model
+ */
+class FabricContractAdapter extends for_couchdb_1.CouchDBAdapter {
+    static { this.PRIVATE_BOOKMARK_PREFIX = "__dcf_pvtbm__"; }
+    static parseSyntheticPrivateBookmark(bookmark) {
+        if (typeof bookmark !== "string")
+            return undefined;
+        if (!bookmark.startsWith(FabricContractAdapter.PRIVATE_BOOKMARK_PREFIX))
+            return undefined;
+        const raw = bookmark.slice(FabricContractAdapter.PRIVATE_BOOKMARK_PREFIX.length);
+        const parsed = Number(raw);
+        return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+    }
+    static buildSyntheticPrivateBookmark(offset) {
+        return `${FabricContractAdapter.PRIVATE_BOOKMARK_PREFIX}${offset}`;
+    }
+    getClient() {
+        throw new core_1.UnsupportedError("Client is not supported in Fabric contracts");
+    }
+    /**
+     * @description Text decoder for converting binary data to strings
+     */
+    static { this.textDecoder = new TextDecoder("utf8"); }
+    static { this.serializer = new SimpleDeterministicSerializer_1.SimpleDeterministicSerializer(); }
+    /**
+     * @description Context constructor for this adapter
+     * @summary Overrides the base Context constructor with FabricContractContext
+     */
+    get Context() {
+        return ContractContext_1.FabricContractContext;
+    }
+    /**
+     * @description Gets the repository constructor for this adapter
+     * @summary Returns the FabricContractRepository constructor for creating repositories
+     * @template M - Type extending Model
+     * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor
+     */
+    repository() {
+        return FabricContractRepository_1.FabricContractRepository;
+    }
+    Paginator(query, size, clazz) {
+        return new FabricContractPaginator_1.FabricContractPaginator(this, query, size, clazz);
+    }
+    async Sequence(options) {
+        return new FabricContractSequence_1.FabricContractSequence(options, this);
+    }
+    Dispatch() {
+        return new FabricContractDispatch_1.FabricContractDispatch();
+    }
+    /**
+     * @description Creates a new FabricContractAdapter instance
+     * @summary Initializes an adapter for interacting with the Fabric state database
+     * @param {void} scope - Not used in this adapter
+     * @param {string} [alias] - Optional alias for the adapter instance
+     */
+    constructor(scope, alias) {
+        super(scope, constants_1.FabricFlavour, alias);
+    }
+    for(config, ...args) {
+        return super.for(config, ...args);
+    }
+    getModelDefaults(clazz) {
+        const m = new clazz();
+        return (decoration_1.Metadata.properties(clazz) || []).reduce((acc, p) => {
+            if (typeof m[p] !== "undefined")
+                acc[p] = m[p];
+            return acc;
+        }, {});
+    }
+    /**
+     * @description Creates a record in the state database
+     * @summary Serializes a model and stores it in the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The record data
+     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the created record
+     */
+    async create(clazz, id, model, ...args) {
+        const { ctx, log } = this.logCtx(args, this.create);
+        this.enforceMirrorAuthorization(clazz, ctx);
+        log.info(`in ADAPTER create with args ${args}`);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
+        const mirrorCollection = ctx.getOrUndefined("mirrorCollection");
+        const fullySegregated = ctx.isFullySegregated && !mirrorCollection;
+        if (!mirrorCollection) {
+            let existing;
+            try {
+                existing = await this.readState(composedKey, ctx);
+            }
+            catch (e) {
+                // eslint-disable-next-line no-ex-assign
+                e = this.parseError(e);
+                if (!(e instanceof db_decorators_1.NotFoundError))
+                    throw e;
+            }
+            if (existing)
+                throw new db_decorators_1.ConflictError(`record with id ${id} in table ${tableName} already exists`);
+        }
+        try {
+            log.info(`adding entry to ${tableName} table with pk ${id}`);
+            if (mirrorCollection) {
+                model = await this.forPrivate(mirrorCollection).putState(composedKey, model, ctx);
+            }
+            else {
+                const defaults = this.getModelDefaults(clazz);
+                // handle public data if not fully segregated
+                if (!fullySegregated) {
+                    if (Object.keys(model).filter((k) => {
+                        if (k === for_couchdb_1.CouchDBKeys.TABLE)
+                            return false;
+                        return !(defaults &&
+                            k in defaults &&
+                            defaults[k] === model[k]);
+                    }).length)
+                        model = await this.putState(composedKey, model, ctx);
+                }
+                // handle segregated writes
+                const data = ctx.getFromChildren("segregatedData");
+                if (data) {
+                    for (const collection in data) {
+                        Object.assign(model, await this.forPrivate(collection).putState(composedKey, data[collection][id], ctx));
+                    }
+                }
+            }
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    async createAll(tableName, id, model, ...args) {
+        if (id.length !== model.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const { log, ctxArgs } = this.logCtx(args, this.createAll);
+        const tableLabel = decorator_validation_1.Model.tableName(tableName);
+        log.debug(`Creating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...ctxArgs)));
+    }
+    /**
+     * @description Reads a record from the state database
+     * @summary Retrieves and deserializes a record from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
+     */
+    async read(clazz, id, ...args) {
+        const { ctx, log } = this.logCtx(args, this.read);
+        log.info(`in ADAPTER read with args ${args}`);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
+        const mirrorCollection = ctx.getOrUndefined("mirrorCollection");
+        const isMirror = ctx.getOrUndefined("mirror");
+        if (isMirror && mirrorCollection) {
+            try {
+                return await this.forPrivate(mirrorCollection).readState(composedKey, ctx);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            finally {
+                ctx.put("mirror", undefined);
+                ctx.put("mirrorCollection", undefined);
+            }
+        }
+        let model;
+        try {
+            model = ctx.isFullySegregated
+                ? {}
+                : await this.readState(composedKey, ctx);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        const readCollections = new Set([
+            ...(ctx.getReadCollections() || []),
+            ...(ctx.consumeReadCollections() || []),
+        ]);
+        for (const col of readCollections) {
+            try {
+                Object.assign(model, await this.forPrivate(col).readState(composedKey, ctx));
+            }
+            catch (e) {
+                const parsed = this.parseError(e);
+                if (parsed instanceof db_decorators_1.NotFoundError)
+                    continue;
+                throw parsed;
+            }
+        }
+        if (!Object.keys(model).length) {
+            throw new db_decorators_1.NotFoundError(`record with id ${id} in table ${tableName} does not exist`);
+        }
+        return model;
+    }
+    /**
+     * @description Retrieves multiple records from the database
+     * @summary Fetches multiple records with the given IDs from the specified table
+     * @param {string} tableName - The name of the table to read from
+     * @param id - The identifiers of the records to retrieve
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to an array of retrieved records
+     */
+    async readAll(clazz, id, ...args) {
+        const { log, ctx } = this.logCtx(args, this.readAll);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.debug(`Reading ${id.length} entries ${tableName} table`);
+        const breakOnSingleFailure = ctx.get("breakOnSingleFailureInBulk") ?? true;
+        const continueOnError = !breakOnSingleFailure;
+        const mirrorCollection = ctx.getOrUndefined("mirrorCollection");
+        const isMirror = ctx.getOrUndefined("mirror");
+        const readMirror = async (clazz, id, ...args) => {
+            if (!mirrorCollection)
+                throw new db_decorators_1.BadRequestError("Missing mirror collection for mirror read");
+            try {
+                const { ctx, log } = this.logCtx(args, readMirror);
+                log.info(`in ADAPTER read with args ${args}`);
+                const tableName = decorator_validation_1.Model.tableName(clazz);
+                const composedKey = ctx.stub.createCompositeKey(tableName, [
+                    String(id),
+                ]);
+                return await this.forPrivate(mirrorCollection).readState(composedKey, ctx);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        };
+        try {
+            const tasks = id.map((i) => () => isMirror && mirrorCollection
+                ? readMirror(clazz, i, ...args, ctx.override({ noEmitSingle: true }))
+                : this.read(clazz, i, ...args, ctx.override({ noEmitSingle: true })));
+            const rawResult = continueOnError
+                ? await (0, core_1.promiseSequence)(tasks, true)
+                : await (0, core_1.promiseSequence)(tasks);
+            return (0, core_1.resolveBulkSequenceResult)(rawResult, continueOnError, log, db_decorators_1.BulkCrudOperationKeys.READ_ALL);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        finally {
+            ctx.put("mirror", undefined);
+            ctx.put("mirrorCollection", undefined);
+        }
+    }
+    /**
+     * @description Updates a record in the state database
+     * @summary Serializes a model and updates it in the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The updated record data
+     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the updated record
+     */
+    async update(clazz, id, model, ...args) {
+        const { ctx, log } = this.logCtx(args, this.update);
+        this.enforceMirrorAuthorization(clazz, ctx);
+        log.info(`in ADAPTER update with args ${args}`);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
+        const mirrorCollection = ctx.getOrUndefined("mirrorCollection");
+        try {
+            log.info(`updating entry in ${tableName} table with pk ${id}`);
+            if (mirrorCollection) {
+                model = await this.forPrivate(mirrorCollection).putState(composedKey, model, ctx);
+            }
+            else {
+                const defaults = this.getModelDefaults(clazz);
+                // handle public data
+                if (Object.keys(model).filter((k) => {
+                    if (k === for_couchdb_1.CouchDBKeys.TABLE)
+                        return false;
+                    return !(defaults &&
+                        k in defaults &&
+                        defaults[k] === model[k]);
+                }).length)
+                    model = await this.putState(composedKey, model, ctx);
+                // handle segregated writes
+                const data = ctx.getFromChildren("segregatedData");
+                if (data) {
+                    for (const collection in data) {
+                        Object.assign(model, await this.forPrivate(collection).putState(composedKey, data[collection][id], ctx));
+                    }
+                }
+            }
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    /**
+     * @description Deletes a record from the state database
+     * @summary Retrieves a record and then removes it from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier to delete
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
+     */
+    async delete(clazz, id, ...args) {
+        const { ctx, log } = this.logCtx(args, this.delete);
+        this.enforceMirrorAuthorization(clazz, ctx);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
+        const mirrorCollection = ctx.getOrUndefined("mirrorCollection");
+        let model;
+        if (mirrorCollection) {
+            try {
+                model = await this.forPrivate(mirrorCollection).readState(composedKey, ctx);
+                await this.forPrivate(mirrorCollection).deleteState(composedKey, ctx);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        else {
+            try {
+                model = ctx.isFullySegregated
+                    ? {}
+                    : await this.readState(composedKey, ctx);
+                if (!ctx.isFullySegregated) {
+                    log.debug(`Deleting entry ${composedKey} from public ledger`);
+                    await this.deleteState(composedKey, ctx);
+                }
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            const collections = ctx.getReadCollections();
+            if (collections && collections.length) {
+                for (const col of collections) {
+                    log.debug(`ensuring collection ${col} has entry for id ${composedKey} before deleting`);
+                    Object.assign(model, await this.forPrivate(col).readState(composedKey, ctx));
+                    log.debug(`Deleting private collection ${col} entry for id ${composedKey}`);
+                    await this.forPrivate(col).deleteState(composedKey, ctx);
+                }
+            }
+        }
+        return model;
+    }
+    async deleteState(id, context) {
+        await context.stub.deleteState(id);
+    }
+    forPrivate(collection) {
+        const toOverride = [
+            this.putState,
+            this.readState,
+            this.deleteState,
+            this.queryResult,
+            this.queryResultPaginated,
+        ].map((fn) => fn.name);
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (!toOverride.includes(prop))
+                    return Reflect.get(target, prop, receiver);
+                return new Proxy(target[prop], {
+                    async apply(fn, thisArg, argsList) {
+                        switch (prop) {
+                            case "putState": {
+                                // putState signature: (id: string, model: Record<string, any>, ctx: FabricContractContext)
+                                const [id, model, ctx] = argsList;
+                                const log = ctx.logger.for(prop);
+                                log.debug(`Private write to ${collection} for ${id.toString()}`);
+                                const data = Buffer.from(FabricContractAdapter.serializer.serialize(model, false));
+                                await ctx.stub.putPrivateData(collection, id.toString(), data);
+                                return model;
+                            }
+                            case "deleteState": {
+                                // deleteState signature: (id: string, context: FabricContractContext)
+                                const [id, ctx] = argsList;
+                                const log = ctx.logger.for(prop);
+                                log.debug(`Private delete on ${collection} for ${id.toString()}`);
+                                await ctx.stub.deletePrivateData(collection, id.toString());
+                                return;
+                            }
+                            case "readState": {
+                                // readState signature: (id: string, ctx: FabricContractContext)
+                                const [id, ctx] = argsList;
+                                const log = ctx.logger.for(prop);
+                                log.debug(`Private read from ${collection} for ${id.toString()}`);
+                                const data = await ctx.stub.getPrivateData(collection, id);
+                                if (!data || !data.toString().length)
+                                    throw new db_decorators_1.NotFoundError(`Record with id ${id} not found`);
+                                try {
+                                    return FabricContractAdapter.serializer.deserialize(data.toString("utf8"));
+                                }
+                                catch {
+                                    return data.toString("utf8");
+                                }
+                            }
+                            case "queryResult": {
+                                const [stub, rawInput, ...args] = argsList;
+                                const { log } = thisArg["logCtx"](args, prop);
+                                try {
+                                    log.debug(`Querying collection ${collection} for ${JSON.stringify(rawInput)}`);
+                                    const res = await stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
+                                    log.verbose(`iterator from collection ${collection} received`);
+                                    return res.iterator || res;
+                                }
+                                catch (e) {
+                                    log.error(e);
+                                    return [];
+                                }
+                            }
+                            case "queryResultPaginated": {
+                                const [stub, rawInput, limit, skip, bookmark, ...args] = argsList;
+                                const { log } = thisArg["logCtx"](args, prop);
+                                const pageSize = Math.max(1, Number(limit) || 250);
+                                const query = { ...rawInput };
+                                const skipValue = Number(skip);
+                                const parsedSkip = Number.isInteger(skipValue) && skipValue >= 0
+                                    ? skipValue
+                                    : undefined;
+                                const syntheticOffset = FabricContractAdapter.parseSyntheticPrivateBookmark(bookmark) ??
+                                    parsedSkip ??
+                                    0;
+                                const hasOpaqueBookmark = bookmark !== undefined &&
+                                    bookmark !== null &&
+                                    bookmark !== "" &&
+                                    typeof bookmark === "string" &&
+                                    !bookmark.startsWith(FabricContractAdapter.PRIVATE_BOOKMARK_PREFIX);
+                                // Keep the query CouchDB-compatible and let Fabric/CouchDB own bookmark semantics.
+                                // Synthetic mode fetches one extra record to detect whether a next page exists.
+                                query.limit = hasOpaqueBookmark ? pageSize : pageSize + 1;
+                                if (hasOpaqueBookmark) {
+                                    query.bookmark = bookmark.toString();
+                                    delete query.skip;
+                                }
+                                else {
+                                    delete query.bookmark;
+                                    if (syntheticOffset > 0) {
+                                        query.skip = syntheticOffset;
+                                    }
+                                    else {
+                                        delete query.skip;
+                                    }
+                                }
+                                log.debug(`Querying collection ${collection} for ${JSON.stringify(query)}`);
+                                const response = await stub.getPrivateDataQueryResult(collection, JSON.stringify(query));
+                                const iterator = (response.iterator ||
+                                    response);
+                                const responseMetadata = response.metadata || iterator.metadata || {};
+                                const responseBookmark = typeof responseMetadata.bookmark === "string"
+                                    ? responseMetadata.bookmark
+                                    : "";
+                                log.verbose(`iterator from collection ${collection} received`);
+                                const paged = [];
+                                let hasMore = false;
+                                try {
+                                    while (true) {
+                                        const res = await iterator.next();
+                                        if (res.done)
+                                            break;
+                                        if (res.value && res.value.value) {
+                                            const key = res.value.key;
+                                            if (paged.length < pageSize) {
+                                                paged.push({
+                                                    key,
+                                                    value: Buffer.isBuffer(res.value.value)
+                                                        ? res.value.value
+                                                        : Buffer.from(res.value.value.toString("utf8")),
+                                                });
+                                            }
+                                            else {
+                                                hasMore = true;
+                                                break; // early exit
+                                            }
+                                        }
+                                    }
+                                }
+                                finally {
+                                    await iterator.close();
+                                }
+                                // Wrap the page in an async iterator for resultIterator()
+                                let idx = 0;
+                                const arrayIterator = {
+                                    async next() {
+                                        if (idx < paged.length) {
+                                            return { value: paged[idx++], done: false };
+                                        }
+                                        return { value: undefined, done: true };
+                                    },
+                                    async close() { },
+                                };
+                                return {
+                                    iterator: arrayIterator,
+                                    metadata: {
+                                        fetchedRecordsCount: paged.length,
+                                        bookmark: responseBookmark ||
+                                            (hasMore
+                                                ? FabricContractAdapter.buildSyntheticPrivateBookmark(syntheticOffset + paged.length)
+                                                : ""),
+                                    },
+                                };
+                            }
+                            default:
+                                throw new db_decorators_1.InternalError(`Unsupported method override ${String(prop)}`);
+                        }
+                    },
+                });
+            },
+        });
+    }
+    async putState(id, model, ctx) {
+        let data;
+        try {
+            data = Buffer.from(FabricContractAdapter.serializer.serialize(model, false));
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(`Failed to serialize record with id ${id}: ${e}`);
+        }
+        await ctx.stub.putState(id.toString(), data);
+        return model;
+    }
+    async readState(id, ctx) {
+        let result;
+        const { log } = this.logCtx([ctx], this.readState);
+        const res = (await ctx.stub.getState(id.toString())).toString();
+        if (!res)
+            throw new db_decorators_1.NotFoundError(`Record with id ${id} not found`);
+        log.silly(`state retrieved under id ${id}`);
+        try {
+            result = FabricContractAdapter.serializer.deserialize(res.toString());
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(`Failed to parse record: ${e}`);
+        }
+        return result;
+    }
+    async queryResult(stub, rawInput, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return stub.getQueryResult(JSON.stringify(rawInput));
+    }
+    async queryResultPaginated(stub, rawInput, limit = 250, page, bookmark, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return stub.getQueryResultWithPagination(JSON.stringify(rawInput), limit, bookmark?.toString());
+    }
+    /**
+     * @description Decodes binary data to string
+     * @summary Converts a Uint8Array to a string using UTF-8 encoding
+     * @param {Uint8Array} buffer - The binary data to decode
+     * @return {string} The decoded string
+     */
+    decode(buffer) {
+        return FabricContractAdapter.textDecoder.decode(buffer);
+    }
+    /**
+     * @description Creates operation flags for Fabric contract operations
+     * @summary Merges default flags with Fabric-specific context information
+     * @template M - Type extending Model
+     * @param {OperationKeys} operation - The operation being performed
+     * @param {Constructor<M>} model - The model constructor
+     * @param {Partial<FabricContractFlags>} flags - Partial flags to merge with defaults
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @return {FabricContractFlags} The merged flags
+     */
+    async flags(operation, model, flags) {
+        let baseFlags = {
+            segregated: false,
+            rebuildWithTransient: false,
+            fullySegregated: false,
+        };
+        if (flags instanceof ContractContext_1.FabricContractContext || flags instanceof core_1.Context) {
+            flags = flags.toOverrides();
+        }
+        baseFlags = Object.assign(baseFlags, flags);
+        const stubFromFlags = flags.stub || flags.stub;
+        const identityFromFlags = flags.identity ||
+            flags.clientIdentity;
+        if (stubFromFlags && identityFromFlags) {
+            const txId = stubFromFlags.getTxID();
+            Object.assign(baseFlags, {
+                stub: stubFromFlags,
+                identity: identityFromFlags,
+                cert: identityFromFlags.getIDBytes().toString(),
+                roles: identityFromFlags.getAttributeValue("roles"),
+                logger: logging_1.Logging.for(operation, {
+                    logLevel: false,
+                    timestamp: false,
+                    correlationId: txId,
+                }, flags),
+                correlationId: txId,
+            });
+        }
+        else {
+            baseFlags = Object.assign(baseFlags, flags || {});
+        }
+        return (await super.flags(operation, model, baseFlags));
+    }
+    /**
+     * @description Creates an index for a model
+     * @summary This method is not implemented for Fabric contracts and returns a resolved promise
+     * @template M - Type extending Model
+     * @param {Constructor<M>} models - The model constructor
+     * @return {Promise<void>} Promise that resolves immediately
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    index(models) {
+        return Promise.resolve(undefined);
+    }
+    /**
+     * @description Processes results from a state query iterator
+     * @summary Iterates through query results and converts them to a structured format
+     * @param {Logger} log - Logger instance for debugging
+     * @param {Iterators.StateQueryIterator} iterator - The state query iterator
+     * @param {boolean} [isHistory=false] - Whether this is a history query
+     * @return {Promise<any[]>} Promise resolving to an array of processed results
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant ResultIterator
+     *   participant Iterator
+     *
+     *   Caller->>ResultIterator: resultIterator(log, iterator, isHistory)
+     *   loop Until done
+     *     ResultIterator->>Iterator: next()
+     *     Iterator-->>ResultIterator: { value, done }
+     *     alt Has value
+     *       ResultIterator->>ResultIterator: Process value based on isHistory
+     *       ResultIterator->>ResultIterator: Add to results array
+     *     end
+     *   end
+     *   ResultIterator->>Iterator: close()
+     *   ResultIterator-->>Caller: allResults
+     */
+    async resultIterator(log, iterator, isHistory = false) {
+        const allResults = [];
+        let res = await iterator.next();
+        while (!res.done) {
+            if (res.value && res.value.value.toString()) {
+                let jsonRes = {};
+                log.debug(res.value.value.toString("utf8"));
+                if (isHistory /* && isHistory === true*/) {
+                    jsonRes.TxId = res.value.txId;
+                    jsonRes.Timestamp = res.value.timestamp;
+                    try {
+                        jsonRes.Value = JSON.parse(res.value.value.toString("utf8"));
+                    }
+                    catch (err) {
+                        log.error(err);
+                        jsonRes.Value = res.value.value.toString("utf8");
+                    }
+                }
+                else {
+                    try {
+                        jsonRes = JSON.parse(res.value.value.toString("utf8"));
+                    }
+                    catch (err) {
+                        log.error(err);
+                        jsonRes = res.value.value.toString("utf8");
+                    }
+                }
+                allResults.push(jsonRes);
+            }
+            res = await iterator.next();
+        }
+        log.debug(`Closing iterator after ${allResults.length} results`);
+        await iterator.close();
+        return allResults;
+    }
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Performs a rich query using CouchDB syntax against the Fabric state database
+     * @template R - The return type
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<R>} Promise resolving to the query results
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant FabricContractAdapter
+     *   participant Stub
+     *   participant StateDB
+     *
+     *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)
+     *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip
+     *   alt With pagination
+     *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)
+     *   else Without pagination
+     *     FabricContractAdapter->>Stub: getQueryResult(query)
+     *   end
+     *   Stub->>StateDB: Execute query
+     *   StateDB-->>Stub: Iterator
+     *   Stub-->>FabricContractAdapter: Iterator
+     *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
+     *   FabricContractAdapter-->>Caller: results
+     */
+    async raw(rawInput, docsOnly = true, ...args) {
+        const { log, ctx, ctxArgs } = this.logCtx(args, this.raw);
+        const enableSegregates = !args.length || args[0] !== true;
+        const fullySegregated = enableSegregates && ctx.isFullySegregated;
+        const { skip, limit } = rawInput;
+        const bookmark = rawInput["bookmark"];
+        const paginationActive = Boolean(limit || skip || bookmark);
+        let resp = { docs: [], bookmark: undefined };
+        // Query public state only when the model is NOT fully segregated
+        if (!fullySegregated) {
+            let iterator;
+            if (limit || skip) {
+                delete rawInput["limit"];
+                delete rawInput["skip"];
+                log.debug(`Retrieving public paginated iterator: limit: ${limit}/ skip: ${skip}`);
+                const response = (await this.queryResultPaginated(ctx.stub, rawInput, limit || Number.MAX_VALUE, skip?.toString(), bookmark, ...[ctx]));
+                resp.bookmark = response.metadata.bookmark;
+                iterator = response.iterator;
+                log.debug(`Retrieved public paging iterator`);
+            }
+            else {
+                log.debug("Retrieving listing public iterator");
+                iterator = (await this.queryResult(ctx.stub, rawInput, ctx));
+            }
+            log.debug(`Retrieved public listing iterator`);
+            resp.docs = (await this.resultIterator(log, iterator));
+            log.debug(`returning ${Array.isArray(resp.docs) ? resp.docs.length : 1} results`);
+        }
+        else {
+            // For fully segregated models, strip pagination fields from rawInput
+            // so the segregated query below can re-apply them cleanly
+            if (limit || skip) {
+                delete rawInput["limit"];
+                delete rawInput["skip"];
+            }
+            log.debug("Skipping public state query (fully segregated model)");
+        }
+        const collections = enableSegregates ? ctx.getReadCollections() : undefined;
+        if (collections && collections.length) {
+            // Build a fresh input with limit/skip/bookmark restored
+            const segregatedInput = { ...rawInput };
+            if (limit)
+                segregatedInput.limit = limit;
+            if (skip)
+                segregatedInput.skip = skip;
+            if (bookmark)
+                segregatedInput["bookmark"] = bookmark;
+            const segregated = [];
+            for (const collection of collections) {
+                log.debug(`Querying from ${collection}`);
+                const fromCols = await this.forPrivate(collection).raw({ ...segregatedInput }, false, true, ...ctxArgs);
+                log.verbose(`received ${fromCols.length} from ${collection}`);
+                segregated.push(fromCols);
+            }
+            if (paginationActive) {
+                // For paginated flows, keep source selection deterministic so
+                // externally generated opaque bookmarks stay valid across pages.
+                if (fullySegregated) {
+                    resp = segregated[0] || resp;
+                }
+                else if (!resp.docs?.length && segregated.length) {
+                    // Preserve public-state priority for mixed models, but allow a
+                    // stable fallback when public query returns no docs.
+                    resp = segregated[0];
+                }
+            }
+            else {
+                // Non-paginated reads can still prefer the richest response.
+                resp = segregated.reduce((acc, curr) => {
+                    if (!acc)
+                        return curr;
+                    if (curr.docs && curr.docs.length >= acc?.docs.length)
+                        return curr;
+                    return acc;
+                }, resp);
+            }
+        }
+        if (docsOnly) {
+            return resp.docs;
+        }
+        return resp;
+    }
+    async view(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ddoc, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    viewName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ..._args) {
+        throw new core_1.UnsupportedError("Fabric contracts do not support CouchDB views.");
+    }
+    Statement(overrides) {
+        return new FabricContractStatement_1.FabricStatement(this, overrides);
+    }
+    async updateAll(tableName, id, model, ...args) {
+        if (id.length !== model.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const { log, ctxArgs } = this.logCtx(args, this.updateAll);
+        const tableLabel = decorator_validation_1.Model.tableName(tableName);
+        log.debug(`Updating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...ctxArgs)));
+    }
+    /**
+     *
+     * @param model
+     * @param {string} pk
+     * @param args
+     */
+    prepare(model, ...args) {
+        const { log, ctx } = this.logCtx(args, this.prepare);
+        const split = decorator_validation_1.Model.segregate(model);
+        const tableName = decorator_validation_1.Model.tableName(model.constructor);
+        const pk = decorator_validation_1.Model.pk(model.constructor);
+        const id = model[pk];
+        const isMirror = ctx.getOrUndefined("mirror");
+        const mapToRecord = function (obj, keysOverride) {
+            if (keysOverride)
+                keysOverride = [...new Set([...keysOverride, pk])];
+            const result = Object.entries(obj).reduce((accum, [key, val]) => {
+                if (typeof val === "undefined")
+                    return accum;
+                if (keysOverride && !keysOverride.includes(key))
+                    return accum;
+                const mappedProp = decorator_validation_1.Model.columnName(model, key);
+                if (this.isReserved(mappedProp))
+                    throw new db_decorators_1.InternalError(`Property name ${mappedProp} is reserved`);
+                val = val instanceof Date ? new Date(val) : val;
+                accum[mappedProp] = val;
+                return accum;
+            }, {});
+            if (Object.keys(result).filter((k) => Boolean(result[k])).length) {
+                // Add table identifier
+                result[for_couchdb_1.CouchDBKeys.TABLE] = tableName;
+            }
+            return result;
+        }.bind(this);
+        log.silly(`Preparing record for ${tableName} table with pk ${model[pk]}`);
+        const segregatedWriteKeys = ctx.getSegregatedWrites();
+        const segregatedWrites = {};
+        // Only apply segregated writes when the current model actually has a transient split.
+        // The same FabricContractContext can be reused across nested operations (for example
+        // sequence upserts during persistent version generation). In those cases, we must not
+        // attempt to apply parent-model segregated write keys to unrelated models.
+        if (segregatedWriteKeys && split.transient && typeof split.transient === "object") {
+            for (const collection in segregatedWriteKeys) {
+                segregatedWrites[collection] = segregatedWrites[collection] || {};
+                segregatedWrites[collection][id] = mapToRecord(ctx.getOrUndefined("forceSegregateWrite")
+                    ? split.model
+                    : (split.transient || {}), segregatedWriteKeys[collection]);
+            }
+        }
+        // In mirror mode, the record should contain ALL model properties (full copy)
+        const record = isMirror ? mapToRecord(model) : mapToRecord(split.model);
+        return {
+            record,
+            id: model[pk],
+            transient: !isMirror && split.transient && Object.keys(split.transient).length
+                ? mapToRecord(split.transient)
+                : undefined,
+            segregated: isMirror ? undefined : segregatedWrites,
+        };
+    }
+    revert(obj, clazz, id, transient, ...args) {
+        const { log, ctx } = this.logCtx(args, this.revert);
+        const ob = {};
+        const pk = decorator_validation_1.Model.pk(clazz);
+        const pkProps = decorator_validation_1.Model.pkProps(clazz);
+        if (pkProps?.type === Number && typeof id === "string") {
+            id = Number(id);
+        }
+        ob[pk] = id;
+        log.silly(`Rebuilding model ${clazz.name} id ${id}`);
+        function mapToModel(r) {
+            const m = (typeof clazz === "string" ? decorator_validation_1.Model.build(ob, clazz) : new clazz(ob));
+            const attributes = decorator_validation_1.Model.getAttributes(clazz);
+            const keys = attributes.length ? attributes : Object.keys(m);
+            return keys
+                .filter((k) => k !== pk)
+                .reduce((accum, key) => {
+                accum[key] =
+                    r[decorator_validation_1.Model.columnName(accum, key)];
+                return accum;
+            }, m);
+        }
+        let result = mapToModel(obj);
+        if (transient && !this.shouldRebuildWithTransient(ctx)) {
+            log.debug(`filtering transient properties: ${Object.keys(transient).join(", ")}`);
+            result = Object.entries(result).reduce((acc, [key, v]) => {
+                if (key === pk || !(key in transient)) {
+                    acc[key] = v;
+                }
+                return acc;
+            }, new clazz());
+        }
+        return result;
+    }
+    shouldRebuildWithTransient(ctx) {
+        if (!ctx)
+            return false;
+        if (ctx.getOrUndefined("rebuildWithTransient"))
+            return true;
+        const operation = ctx.getOrUndefined("operation");
+        if (!operation)
+            return true;
+        const op = operation.toString().toLowerCase();
+        return !core_1.TransactionOperationKeys.map((k) => k.toLowerCase()).includes(op);
+    }
+    getContextMsp(context) {
+        const identity = context.get("identity");
+        if (!identity)
+            return undefined;
+        if (typeof identity === "string")
+            return identity;
+        try {
+            return identity.getMSPID();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    enforceMirrorAuthorization(clazz, ctx) {
+        const mirrorMeta = decorator_validation_1.Model.mirroredAt(clazz);
+        if (!mirrorMeta)
+            return;
+        const msp = this.getContextMsp(ctx);
+        if (!msp)
+            return;
+        if (msp === mirrorMeta.mspId ||
+            (mirrorMeta.condition && mirrorMeta.condition(msp))) {
+            throw new core_1.AuthorizationError(`Organization ${msp} is not authorized to modify mirrored data`);
+        }
+    }
+    createPrefix(tableName, id, model, ...args) {
+        const { ctxArgs } = this.logCtx(args, this.createPrefix);
+        const record = {};
+        record[for_couchdb_1.CouchDBKeys.TABLE] = decorator_validation_1.Model.tableName(tableName);
+        Object.assign(record, model);
+        return [tableName, id, record, ...ctxArgs];
+    }
+    updatePrefix(tableName, id, model, ...args) {
+        const { ctxArgs } = this.logCtx(args, this.updatePrefix);
+        const record = {};
+        record[for_couchdb_1.CouchDBKeys.TABLE] = decorator_validation_1.Model.tableName(tableName);
+        Object.assign(record, model);
+        return [tableName, id, record, ...ctxArgs];
+    }
+    createAllPrefix(tableName, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[for_couchdb_1.CouchDBKeys.TABLE] = decorator_validation_1.Model.tableName(tableName);
+            Object.assign(record, models[count]);
+            return record;
+        });
+        return [tableName, ids, records, ctx];
+    }
+    updateAllPrefix(tableName, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[for_couchdb_1.CouchDBKeys.TABLE] = decorator_validation_1.Model.tableName(tableName);
+            Object.assign(record, models[count]);
+            return record;
+        });
+        return [tableName, ids, records, ctx];
+    }
+    parseError(err, reason) {
+        return FabricContractAdapter.parseError(reason || err);
+    }
+    logCtx(args, operation, allowCreate = false, overrides) {
+        if (!allowCreate)
+            return super.logCtx(args, operation, allowCreate, overrides);
+        return super.logCtx
+            .call(this, args, operation, allowCreate, overrides)
+            .then((res) => {
+            if (!(res.ctx instanceof ContractContext_1.FabricContractContext))
+                throw new db_decorators_1.InternalError(`Invalid context binding`);
+            return Object.assign(res, {
+                stub: res.ctx.stub,
+                identity: res.ctx.identity,
+            });
+        });
+    }
+    async updateObservers(table, event, id, ...args) {
+        if (!this.observerHandler)
+            throw new db_decorators_1.InternalError("ObserverHandler not initialized. Did you register any observables?");
+        const { ctx, ctxArgs } = this.logCtx(args, this.updateObservers);
+        if (ctx.isFullySegregated)
+            return;
+        if (ctx.getOrUndefined("noEmit"))
+            return;
+        if (!ctx.stub)
+            return;
+        const isBulk = Array.isArray(id);
+        const emitSingle = !ctx.getOrUndefined("noEmitSingle");
+        const emitBulk = !ctx.getOrUndefined("noEmitBulk");
+        if ((isBulk && emitBulk) || (!isBulk && emitSingle)) {
+            // Pass the MSP owner from stub and the result payload (if any) in the
+            // positions the handler expects: (table, event, id, owner?, payload?, ctx)
+            const mspId = ctx.stub.getMspID ? ctx.stub.getMspID() : undefined;
+            const nonCtxArgs = ctxArgs.slice(0, -1); // everything before ctx
+            const payload = nonCtxArgs.length > 0 ? nonCtxArgs[0] : undefined;
+            await this.observerHandler.updateObservers(table, event, id, mspId, payload, ctx);
+        }
+    }
+    static parseError(err) {
+        // if (
+        //   MISSING_PRIVATE_DATA_REGEX.test(
+        //     typeof err === "string" ? err : err.message
+        //   )
+        // )
+        //   return new UnauthorizedPrivateDataAccess(err) as E;
+        const msg = typeof err === "string" ? err : err.message;
+        if (msg.includes(db_decorators_1.NotFoundError.name))
+            return new db_decorators_1.NotFoundError(err);
+        if (msg.includes(db_decorators_1.ConflictError.name))
+            return new db_decorators_1.ConflictError(err);
+        if (msg.includes(db_decorators_1.BadRequestError.name))
+            return new db_decorators_1.BadRequestError(err);
+        if (msg.includes(core_1.QueryError.name))
+            return new core_1.QueryError(err);
+        if (msg.includes(core_1.PagingError.name))
+            return new core_1.PagingError(err);
+        if (msg.includes(core_1.UnsupportedError.name))
+            return new core_1.UnsupportedError(err);
+        if (msg.includes(core_1.MigrationError.name))
+            return new core_1.MigrationError(err);
+        if (msg.includes(core_1.ObserverError.name))
+            return new core_1.ObserverError(err);
+        if (msg.includes(core_1.AuthorizationError.name))
+            return new core_1.AuthorizationError(err);
+        if (msg.includes(core_1.ForbiddenError.name))
+            return new core_1.ForbiddenError(err);
+        if (msg.includes(core_1.ConnectionError.name))
+            return new core_1.ConnectionError(err);
+        if (msg.includes(db_decorators_1.SerializationError.name))
+            return new db_decorators_1.SerializationError(err);
+        if (msg.includes("no ledger context"))
+            return new errors_1.MissingContextError(`No context found. this can be caused by debugging: ${msg}`);
+        return new db_decorators_1.InternalError(err);
+    }
+    /**
+     * @description Static method for decoration overrides
+     * @summary Overrides/extends decaf decoration with Fabric-specific functionality
+     * @static
+     * @override
+     * @return {void}
+     */
+    static decoration() {
+        super.decoration();
+        decoration_1.Decoration.flavouredAs(constants_1.FabricFlavour)
+            .for(core_1.PersistenceKeys.CREATED_BY)
+            .define({
+            decorator: function createdBy() {
+                return (0, decoration_1.apply)((0, db_decorators_1.onCreate)(createdByOnFabricCreateUpdate), (0, decoration_1.propMetadata)(core_1.PersistenceKeys.CREATED_BY, {}));
+            },
+        })
+            .apply();
+        decoration_1.Decoration.flavouredAs(constants_1.FabricFlavour)
+            .for(core_1.PersistenceKeys.UPDATED_BY)
+            .define({
+            decorator: function createdBy() {
+                return (0, decoration_1.apply)((0, db_decorators_1.onCreateUpdate)(createdByOnFabricCreateUpdate), (0, decoration_1.propMetadata)(core_1.PersistenceKeys.UPDATED_BY, {}));
+            },
+        })
+            .apply();
+        decoration_1.Decoration.flavouredAs(constants_1.FabricFlavour)
+            .for(core_1.PersistenceKeys.COLUMN)
+            .extend((0, fabric_contract_api_1.Property)())
+            .apply();
+        decoration_1.Decoration.flavouredAs(constants_1.FabricFlavour)
+            .for(decorator_validation_1.ValidationKeys.DATE)
+            .extend(function fabricProperty() {
+            return (target, prop) => {
+                (0, fabric_contract_api_1.Property)(prop, "string:date")(target, prop);
+            };
+        });
+        decoration_1.Decoration.flavouredAs(constants_1.FabricFlavour)
+            .for(core_1.PersistenceKeys.TABLE)
+            .extend(function table(obj) {
+            const chain = [];
+            let current = typeof obj === "function"
+                ? decoration_1.Metadata.constr(obj)
+                : decoration_1.Metadata.constr(obj.constructor);
+            while (current && current !== Object && current.prototype) {
+                chain.push(current);
+                current = Object.getPrototypeOf(current);
+            }
+            console.log(chain.map((c) => c.name || c));
+            // Apply from the base class down to the decorated class
+            while (chain.length > 0) {
+                const constructor = chain.pop();
+                console.log(`Calling on ${constructor.name}`);
+                (0, fabric_contract_api_1.Object)()(constructor);
+            }
+            return (0, fabric_contract_api_1.Object)()(obj);
+        })
+            .apply();
+    }
+}
+exports.FabricContractAdapter = FabricContractAdapter;
+FabricContractAdapter.decoration();
+core_1.Adapter.setCurrent(constants_1.FabricFlavour);
+//# sourceMappingURL=ContractAdapter.js.map