@decaf-ts/for-fabric 0.1.47 → 0.1.48

package/dist/for-fabric.js

@@ -1,2 +1,2002 @@
-import{CouchDBStatement as t,CouchDBKeys as e,CouchDBGroupOperator as r,CouchDBOperator as i,CouchDBPaginator as n,CouchDBAdapter as s}from"@decaf-ts/for-couchdb";import{Model as a,JSONSerializer as o,ModelKeys as c,ValidationKeys as l,required as u,model as g}from"@decaf-ts/decorator-validation";import{Context as d,ObserverHandler as h,Adapter as p,Repository as y,QueryError as w,PreparedStatementKeys as f,PersistenceKeys as m,Condition as x,Sequence as b,SequenceModel as S,UUID as v,Serial as A,PagingError as C,OrderDirection as k,UnsupportedError as O,MigrationError as $,ObserverError as N,AuthorizationError as R,ForbiddenError as z,ConnectionError as P,pk as E,column as T,table as B,BaseModel as D}from"@decaf-ts/core";import{OperationKeys as I,BulkCrudOperationKeys as F,BaseError as q,InternalError as j,DBKeys as _,NotFoundError as J,ConflictError as L,SerializationError as M,BadRequestError as U,onCreate as Q,onCreateUpdate as H,ValidationError as V}from"@decaf-ts/db-decorators";import{Property as K,Object as Y,Contract as G,Context as W,Transaction as X}from"fabric-contract-api";import{Metadata as Z,Decoration as tt,propMetadata as et}from"@decaf-ts/decoration";import{Logging as rt,MiniLogger as it,NumericLogLevels as nt,LogLevel as st}from"@decaf-ts/logging";import{__decorate as at,__metadata as ot}from"tslib";class ct extends d{constructor(){super()}get stub(){return this.get("stub")}get timestamp(){return this.stub.getDateTimestamp()}get identity(){return this.get("identity")}toString(){return"fabric ctx"+(this.stub?" with stub":"without stub")}}class lt extends h{constructor(t=[I.CREATE,I.UPDATE,I.DELETE,F.CREATE_ALL,F.UPDATE_ALL,F.DELETE_ALL]){super(),this.supportedEvents=t}async updateObservers(t,e,r,...i){const{log:n,ctx:s}=p.logCtx(i,this.updateObservers),{stub:a}=s,[o,c]=i,l="string"==typeof t?t:t.name;if(-1!==this.supportedEvents.indexOf(e)){n.debug(`Emitting ${e} event`);const t=((t,e,r)=>{const i=[t,e];return r&&i.push(r),i.join("_")})(l,e,o);a.setEvent(t,Buffer.from(JSON.stringify({id:r})))}else a.setEvent(e,Buffer.from(JSON.stringify(c)))}}class ut extends y{constructor(t,e,r){super(t,e),this.trackedEvents=r,this._overrides=Object.assign({},super._overrides,{ignoreValidation:!1,ignoreHandlers:!1,allowRawStatements:!0,forcePrepareSimpleQueries:!1,forcePrepareComplexQueries:!1})}async paginateBy(t,e,r={offset:1,limit:10},...i){let{offset:n,bookmark:s,limit:o}=r;if(!n&&!s)throw new w("PaginateBy needs a page or a bookmark");const c=await d.args(f.PAGE_BY,this.class,i,this.adapter,this._overrides||{}),{log:l,ctxArgs:u}=this.logCtx(c.args,this.paginateBy);let g;if(l.verbose(`paginating ${a.tableName(this.class)} with page size ${o}`),s)g=await this.override({forcePrepareComplexQueries:!1,forcePrepareSimpleQueries:!1}).select().where(this.attr(a.pk(this.class)).gt(s)).orderBy([t,e]).paginate(o,...u),n=1;else{if(!n)throw new w("PaginateBy needs a page or a bookmark");g=await this.override({forcePrepareComplexQueries:!1,forcePrepareSimpleQueries:!1}).select().orderBy([t,e]).paginate(o,...u)}const h=await g.page(n,...u);return g.serialize(h)}async statement(t,...e){if(!y.statements(this,t))throw new w("Invalid prepared statement requested "+t);const r=await d.args(m.STATEMENT,this.class,e,this.adapter,this._overrides||{});r.context.logger&&r.context.logger.info(`Repo statement: ${t} + ${e}`);const{log:i,ctxArgs:n}=this.logCtx(r.args,this.statement);let s;i.verbose(`Executing prepared statement ${t} with args ${n}`);try{s=await this[t](...n)}catch(e){if(e instanceof q)throw e;throw new j(`Failed to execute prepared statement ${t} with args ${n}: ${e}`)}return s}ObserverHandler(){return new lt}async updateObservers(t,e,r,...i){if(!this.trackedEvents||-1!==this.trackedEvents.indexOf(e))return await super.updateObservers(t,e,r,...i)}}class gt extends t{constructor(t){super(t)}async raw(t,...e){const{ctx:r}=this.logCtx(e,this.raw),i=await this.adapter.raw(t,!0,r),n=a.pk(this.fromSelector),s=Z.get(this.fromSelector,Z.key(_.ID,n))?.type;return this.selectSelector?i:i.map(t=>this.processRecord(t,n,s,r))}build(){const t={};t[e.TABLE]={},t[e.TABLE]=a.tableName(this.fromSelector);const n={selector:t};if(this.selectSelector&&(n.fields=this.selectSelector),this.whereCondition){const t=this.parseCondition(x.and(this.whereCondition,x.attribute(e.TABLE).eq(n.selector[e.TABLE]))).selector,i=Object.keys(t);if(1===i.length&&-1!==Object.values(r).indexOf(i[0]))switch(i[0]){case r.AND:t[r.AND]=[...Object.values(t[r.AND]).reduce((t,e)=>{const i=Object.keys(e);if(1!==i.length)throw Error("Too many keys in query selector. should be one");const n=i[0];return n===r.AND?t.push(...e[n]):t.push(e),t},[])],n.selector=t;break;case r.OR:{const e={};e[r.AND]=[t,...Object.entries(n.selector).map(([t,e])=>{const r={};return r[t]=e,r})],n.selector=e;break}default:throw Error("This should be impossible")}else Object.entries(t).forEach(([t,e])=>{n.selector[t],n.selector[t]=e})}if(this.orderBySelector){n.sort=n.sort||[],n.selector=n.selector||{};const[t,e]=this.orderBySelector,r={};r[t]=e,n.sort.push(r),n.selector[t]||(n.selector[t]={},n.selector[t][i.BIGGER]=null)}return this.limitSelector&&(n.limit=this.limitSelector),this.offsetSelector&&(n.skip=this.offsetSelector),n}}class dt extends b{constructor(t,e){super(t,e)}async current(...t){const e=(await d.args(I.READ,S,t,this.adapter)).context,{name:r,startWith:i}=this.options;try{const t=await this.repo.read(r,e);return this.parse(t.current)}catch(t){const n=e.logger.for(this.current);if(t instanceof J){let t;try{n.debug(`Trying to resolve current sequence ${r} value from context`),t=e.get(r),n.debug(`Retrieved cached current value for sequence ${r}: ${t}`)}catch(e){n.info(`No cached value for sequence ${r} in context`),t=i}try{return this.parse(t)}catch(t){throw new j(`Failed to parse initial value for sequence ${i}: ${t}`)}}throw new j(`Failed to retrieve current value for sequence ${r}: ${t}`)}}async increment(t,e){const r=e.logger.for(this.increment),{type:i,incrementBy:n,name:s}=this.options;if(!s)throw new j("Sequence name is required");return r.info("Obtaining sequence lock for sequence "+s),dt.lock.execute(async()=>{const a=t||n;if(a%n!==0)throw new j("Value to increment does not consider the incrementBy setting: "+n);const o="function"==typeof i&&i?.name?i.name:i,c=await this.current(e);async function l(t){return t instanceof Promise&&(t=await t),e.logger.for(l).info(`Storing new ${s} seq value in cache: ${t.current}`),e.cache.put(s,t.current),t}const u=async t=>{try{return await l(this.repo.update(new S({id:s,current:t}),e))}catch(i){if(i instanceof J)return r.debug(`Sequence create ${s} current=${c} next=${t}`),l(this.repo.create(new S({id:s,current:t}),e));throw i}};if("uuid"===o)for(;;){const t=v.instance.generate(c);try{const e=await u(t);return r.debug(`Sequence uuid increment ${s} current=${c} next=${t}`),e.current}catch(t){if(t instanceof L)continue;throw t}}const g=(t=>{switch(o){case Number.name:return this.parse(t)+a;case BigInt.name:return this.parse(t)+BigInt(a);case String.name:return this.parse(t);case"serial":return A.instance.generate(t);default:throw new j("Should never happen")}})(c),d=await u(g);return r.debug(`Sequence.increment ${s} current=${c} next=${g}`),d.current},s)}}var ht,pt;(t=>{t.PRIVATE="private",t.SHARED="shared",t.FABRIC="fabric.",t.OWNEDBY="owned-by",t.TRANSACTION_ID="transaction-id"})(ht||(ht={})),(t=>{t.X509="X.509"})(pt||(pt={}));const yt="hlf-fabric";class wt extends o{constructor(){super()}deserialize(t,e){return JSON.parse(t)}serialize(t,e=!0){return require("json-stringify-deterministic")(require("sort-keys-recursive")(this.preSerialize(t,e)))}preSerialize(t,e=!0){const r=Object.assign({},t);let i;try{i=Z.modelName(t.constructor)}catch(t){i=void 0}function n(t){return"object"!=typeof t?t:Array.isArray(t)?t.map(n):this.preSerialize(t)}return e&&(r[c.ANCHOR]=i||t.constructor.name),a.relations(t).forEach(t=>{r[t]=n.call(this,r[t])}),r}}class ft extends it{constructor(t,e,r){super(t,e),this.logger=r?r.logging.getLogger(t):new it(t,e)}log(t,e,r){if(nt[this.config("level")]<nt[t])return;let i;switch(t){case st.info:i=this.logger.info;break;case st.verbose:i=this.logger.verbose;break;case st.debug:i=this.logger.debug;break;case st.error:i=this.logger.error;break;case st.warn:i=this.logger.warn;break;case st.silly:i=this.logger.silly;break;default:throw new j("Invalid log level")}i.call(this.logger,this.createLog(t,e,r))}}rt.setFactory((t,e,r)=>new ft(t||ft.name,e||{},r));class mt extends n{constructor(t,e,r,i){super(t,e,r,i)}prepare(t){const e=Object.assign({},t);return e.limit&&(this.limit=e.limit),e.limit=this.size,e}async page(t=1,...e){const{ctxArgs:r,ctx:i}=this.adapter.logCtx(e,this.page);if(this.isPreparedStatement())return this.pagePrepared(t,...r);const n=Object.assign({},this.statement);if(!this._recordCount||!this._totalPages){this._totalPages=this._recordCount=0;const t=await this.adapter.raw({...n,limit:void 0},!0,i)||[];if(this._recordCount=t.length,this._recordCount>0){const t=n?.limit||this.size;this._totalPages=Math.ceil(this._recordCount/t)}}if(this.validatePage(t),1!==t){if(!this._bookmark)throw new C("No bookmark. Did you start in the first page?");n.bookmark=this._bookmark}const s=await this.adapter.raw(n,!1,i);if(!this.clazz)throw new C("No statement target defined");const o=a.pk(this.clazz),c=Z.get(this.clazz,Z.key(_.ID,o))?.type,l=n.fields&&n.fields.length?s:s.map(t=>this.adapter.revert(t,this.clazz,b.parseValue(c,t[o]),void 0,i)),u=n.sort?.[0]||k.DSC;return this._bookmark=l[u===k.ASC?l.length-1:0][o],this._currentPage=t,l}}class xt extends j{constructor(t){super(t,xt.name)}}class bt extends j{constructor(t){super(t,bt.name)}}class St extends j{constructor(t){super(t,St.name)}}class vt extends j{constructor(t){super(t,vt.name,500)}}class At extends q{constructor(t){super(At.name,t,409)}}async function Ct(t,e,r,i){try{const e=t.get("identity");i[r]=e.getID()}catch(t){throw new O("No User found in context. Please provide a user in the context")}}async function kt(t,e,r,i){if(!e.type||i[r])return;let n;e.name||(e.name=a.sequenceName(i,"pk"));try{n=await this.adapter.Sequence(e)}catch(t){throw new j(`Failed to instantiate Sequence ${e.name}: ${t}`)}const s=await n.next(t);Object.defineProperty(i,r,{enumerable:!0,writable:!1,configurable:!0,value:s})}class Ot extends s{getClient(){throw new O("Client is not supported in Fabric contracts")}static{this.textDecoder=new TextDecoder("utf8")}static{this.serializer=new wt}repository(){return ut}Paginator(t,e,r){return new mt(this,t,e,r)}async Sequence(t){return new dt(t,this)}constructor(t,e){super(t,yt,e),this.Context=ct}for(t,...e){return super.for(t,...e)}async create(t,e,r,...i){const{ctx:n,log:s}=this.logCtx(i,this.create);s.info("in ADAPTER create with args "+i);const o=a.tableName(t);try{s.info(`adding entry to ${o} table with pk ${e}`);const t=n.stub.createCompositeKey(o,[e+""]);r=await this.putState(t,r,n)}catch(t){throw this.parseError(t)}return r}async read(t,e,...r){const{ctx:i,log:n}=this.logCtx(r,this.read);n.info("in ADAPTER read with args "+r);const s=a.tableName(t);let o;try{const t=i.stub.createCompositeKey(s,[e+""]);o=await this.readState(t,i)}catch(t){throw this.parseError(t)}return o}async update(t,e,r,...i){const{ctx:n,log:s}=this.logCtx(i,this.update),o=a.tableName(t);try{s.verbose(`updating entry to ${o} table with pk ${e}`);const t=n.stub.createCompositeKey(o,[e+""]);r=await this.putState(t,r,n)}catch(t){throw this.parseError(t)}return r}async delete(t,e,...r){const{ctx:i,log:n,ctxArgs:s}=this.logCtx(r,this.delete),o=a.tableName(t);let c;try{const r=i.stub.createCompositeKey(o,[e+""]);c=await this.read(t,e,...s),n.verbose(`deleting entry with pk ${e} from ${o} table`),await this.deleteState(r,i)}catch(t){throw this.parseError(t)}return c}async deleteState(t,e){const{ctx:r}=this.logCtx([e],this.deleteState);await r.stub.deleteState(t)}forPrivate(t){const e=[this.putState,this.readState,this.deleteState,this.queryResult,this.queryResultPaginated].map(t=>t.name);return new Proxy(this,{get:(r,i,n)=>e.includes(i)?new Proxy(r[i],{async apply(e,r,n){switch(i){case"putState":{const[e,r,i]=n;return await e.putPrivateData(t,r.toString(),i),i}case"deleteState":{const[e,r]=n;return e.deletePrivateData(t,r)}case"readState":{const[e,r]=n;return e.getPrivateData(t,r)}case"queryResult":{const[e,r]=n;return e.getPrivateDataQueryResult(t,r)}case"queryResultPaginated":{const[e,r,i,s]=n,a=await e.getPrivateDataQueryResult(t,r),o=[];let c=0,l=!s,u=null;for(;;){const t=await a.next();if(t.value&&t.value.value.toString()){const e=t.value.key,r=t.value.value.toString("utf8");if(!l){e===s?.toString()&&(l=!0);continue}if(o.push({Key:e,Record:JSON.parse(r)}),u=e,c++,c>=i)return await a.close(),{iterator:o,metadata:{fetchedRecordsCount:o.length,bookmark:u}}}if(t.done)return await a.close(),{iterator:o,metadata:{fetchedRecordsCount:o.length,bookmark:""}}}}default:throw new j("Unsupported method override "+i)}}}):Reflect.get(r,i,n)})}async putState(t,e,r){let i;const{log:n}=this.logCtx([r],this.putState);try{i=Buffer.from(Ot.serializer.serialize(e,!1))}catch(e){throw new M(`Failed to serialize record with id ${t}: ${e}`)}const s=r.get("segregated");return s?await r.stub.putPrivateData(s,t.toString(),i):await r.stub.putState(t.toString(),i),n.silly(`state stored${s?` in ${s} collection`:""} under id ${t}`),e}async readState(t,e){let r;const{log:i}=this.logCtx([e],this.readState);let n;const s=e.get("segregated");if(n=s?(await e.stub.getPrivateData(s,t.toString())).toString():(await e.stub.getState(t.toString())).toString(),!n)throw new J(`Record with id ${t}${s?` in ${s} collection`:""} not found`);i.silly(`state retrieved from${s?` ${s} collection`:""} under id ${t}`);try{r=Ot.serializer.deserialize(n.toString())}catch(t){throw new M("Failed to parse record: "+t)}return r}async queryResult(t,e,...r){const{ctx:i}=this.logCtx(r,this.readState);let n;const s=i.get("segregated");return n=s?await i.stub.getPrivateDataQueryResult(s,JSON.stringify(e)):await t.getQueryResult(JSON.stringify(e)),n}async queryResultPaginated(t,e,r=250,i,...n){const{ctx:s}=this.logCtx(n,this.readState);let a;const o=s.get("segregated");return o?(e.selector={...e.selector,_id:i?{$gt:i.toString()}:{$gte:""}},a={iterator:await t.getPrivateDataQueryResult(o,JSON.stringify(e)),metadata:{fetchedRecordsCount:r,bookmark:""}}):a=await t.getQueryResultWithPagination(JSON.stringify(e),r,i?.toString()),a}mergeModels(t){const e=t=>Object.entries(t).reduce((t,[e,r])=>(void 0!==r&&(t[e]=r),t),{});let r=t.pop();for(const i of t)r=Object.assign({},e(r),e(i));return r}decode(t){return Ot.textDecoder.decode(t)}async flags(t,e,r,i,...n){const s={stub:i.stub,segregated:!1};return Object.assign(s,i instanceof ct?{logger:i.logger,identity:i.identity,correlationId:i.stub.getTxID()}:{identity:i.clientIdentity,logger:new ft(this,void 0,i),correlationId:i.stub.getTxID()}),await super.flags(t,e,s,...n)}index(t){return Promise.resolve(void 0)}async resultIterator(t,e,r=!1){const i=[];let n=await e.next();for(;!n.done;){if(n.value&&n.value.value.toString()){let e={};if(t.debug(n.value.value.toString("utf8")),r){e.TxId=n.value.txId,e.Timestamp=n.value.timestamp;try{e.Value=JSON.parse(n.value.value.toString("utf8"))}catch(r){t.error(r),e.Value=n.value.value.toString("utf8")}}else try{e=JSON.parse(n.value.value.toString("utf8"))}catch(r){t.error(r),e=n.value.value.toString("utf8")}i.push(e)}n=await e.next()}return t.debug(`Closing iterator after ${i.length} results`),e.close(),i}async raw(t,e=!0,...r){const{log:i,stub:n,ctx:s}=this.logCtx(r,this.raw),{skip:a,limit:o}=t;let c;o||a?(delete t.limit,delete t.skip,i.debug(`Retrieving paginated iterator: limit: ${o}/ skip: ${a}`),c=(await this.queryResultPaginated(n,t,o||250,a?.toString(),s)).iterator):(i.debug("Retrieving iterator"),c=await this.queryResult(n,t,s)),i.debug("Iterator acquired");const l=await this.resultIterator(i,c);return i.debug(`returning ${Array.isArray(l)?l.length:1} results`),l}Statement(){return new gt(this)}async createAll(t,e,r,...i){if(e.length!==r.length)throw new j("Ids and models must have the same length");const{log:n,ctxArgs:s}=this.logCtx(i,this.createAll),o=a.tableName(t);return n.debug(`Creating ${e.length} entries ${o} table`),Promise.all(e.map((e,i)=>this.create(t,e,r[i],...s)))}async updateAll(t,e,r,...i){if(e.length!==r.length)throw new j("Ids and models must have the same length");const{log:n,ctxArgs:s}=this.logCtx(i,this.updateAll),o=a.tableName(t);return n.debug(`Updating ${e.length} entries ${o} table`),Promise.all(e.map((e,i)=>this.update(t,e,r[i],...s)))}prepare(t,...e){const{log:r}=this.logCtx(e,this.prepare),i=a.tableName(t.constructor),n=a.pk(t.constructor),s=a.segregate(t),o=Object.entries(s.model).reduce((e,[r,i])=>{if(void 0===i)return e;const n=a.columnName(t,r);if(this.isReserved(n))throw new j(`Property name ${n} is reserved`);return e[n]=i,e},{});return r.silly(`Preparing record for ${i} table with pk ${t[n]}`),{record:o,id:t[n],transient:s.transient}}revert(t,e,r,i,...n){const{log:s}=this.logCtx(n,this.revert),o={};o[a.pk(e)]=r;const c="string"==typeof e?a.build(o,e):new e(o);s.silly(`Rebuilding model ${c.constructor.name} id ${r}`);const l=Object.keys(c).reduce((e,r)=>(e[r]=t[a.columnName(e,r)],e),c);return i&&(s.debug("re-adding transient properties: "+Object.keys(i).join(", ")),Object.entries(i).forEach(([t,e])=>{if(t in l&&void 0!==l[t])throw new j(`Transient property ${t} already exists on model ${c.constructor.name}. should be impossible`);l[t]=e})),l}createPrefix(t,r,i,...n){const{ctxArgs:s}=this.logCtx(n,this.createPrefix),o={};return o[e.TABLE]=a.tableName(t),Object.assign(o,i),[t,r,o,...s]}updatePrefix(t,r,i,...n){const{ctxArgs:s}=this.logCtx(n,this.updatePrefix),o={};return o[e.TABLE]=a.tableName(t),Object.assign(o,i),[t,r,o,...s]}createAllPrefix(t,r,i,...n){if(r.length!==i.length)throw new j("Ids and models must have the same length");const s=n.pop(),o=r.map((r,n)=>{const s={};return s[e.TABLE]=a.tableName(t),Object.assign(s,i[n]),s});return[t,r,o,s]}updateAllPrefix(t,r,i,...n){if(r.length!==i.length)throw new j("Ids and models must have the same length");const s=n.pop(),o=r.map((r,n)=>{const s={};return s[e.TABLE]=a.tableName(t),Object.assign(s,i[n]),s});return[t,r,o,s]}parseError(t,e){return Ot.parseError(e||t)}logCtx(t,e){return Ot.logCtx.call(this,t,e)}static logCtx(t,e){if(1>t.length)throw new j("No context provided");const r=t.pop();if(!(r instanceof d))throw new j("No context provided");if(t.filter(t=>t instanceof d).length>1)throw Error("here");const i=this?r.logger.for(this).for(e):r.logger.clear().for(this).for(e);return{ctx:r,log:e?i.for(e):i,stub:r.stub,identity:r.identity,ctxArgs:[...t,r]}}static parseError(t){const e="string"==typeof t?t:t.message;return e.includes(J.name)?new J(t):e.includes(L.name)?new L(t):e.includes(U.name)?new U(t):e.includes(w.name)?new w(t):e.includes(C.name)?new C(t):e.includes(O.name)?new O(t):e.includes($.name)?new $(t):e.includes(N.name)?new N(t):e.includes(R.name)?new R(t):e.includes(z.name)?new z(t):e.includes(P.name)?new P(t):e.includes(M.name)?new M(t):e.includes("no ledger context")?new vt("No context found. this can be caused by debugging: "+e):new j(t)}static decoration(){super.decoration(),tt.flavouredAs(yt).for(m.CREATED_BY).define(Q(Ct),et(m.CREATED_BY,{})).apply(),tt.flavouredAs(yt).for(m.UPDATED_BY).define(H(Ct),et(m.UPDATED_BY,{})).apply(),tt.flavouredAs(yt).for(m.COLUMN).extend(K()).apply(),tt.flavouredAs(yt).for(l.DATE).extend(()=>(t,e)=>{K(e,"string:date")(t,e)}),tt.flavouredAs(yt).for(m.TABLE).extend(t=>{const e=[];let r="function"==typeof t?Z.constr(t):Z.constr(t.constructor);for(;r&&r!==Object&&r.prototype;)e.push(r),r=Object.getPrototypeOf(r);for(;e.length>0;){const t=e.pop();Y()(t)}return Y()(t)}).apply()}}Ot.decoration(),p.setCurrent(yt);class $t extends o{constructor(){super()}preSerialize(t){const e=Object.assign({},t);let r;try{r=Z.modelName(t.constructor)}catch(t){r=void 0}e[c.ANCHOR]=r||t.constructor.name;const i=function t(e){const r=this;return"object"!=typeof e?e:Array.isArray(e)?e.map(e=>t.call(r,e)):this.preSerialize.call(this,e)}.bind(this);return a.relations(t).forEach(t=>{e[t]=i(e[t])}),e}deserialize(t){const e=JSON.parse(t),r=e[c.ANCHOR];if(!r)throw Error("Could not find class reference in serialized model");return a.build(e,r)}serialize(t){return require("json-stringify-deterministic")(require("sort-keys-recursive")(this.preSerialize(t)))}}Y()(Date);class Nt extends G{static{this.adapter=new Ot}static{this.serializer=new $t}constructor(t,e){super(t),this.clazz=e,this.initialized=!1,this.repo=y.forModel(e)}async listBy(t,e,r,...i){const{ctxArgs:n,log:s}=await this.logCtx([...i,t],this.listBy);return s.info(`Running listBy key ${e}, order ${r} and args ${n}`),this.repo.listBy(e,r,...n)}async paginateBy(t,e,r,i={offset:1,limit:10},...n){const{ctxArgs:s,log:a}=await this.logCtx([...n,t],this.paginateBy);return a.info(`Running paginateBy key ${e}, order ${r} with size ${i.limit} and args ${s}`),this.repo.paginateBy(e,r,i,...s)}async findOneBy(t,e,r,...i){const{ctxArgs:n,log:s}=await this.logCtx([...i,t],this.findOneBy);return s.info(`Running findOneBy key ${e}, value: ${r} with args ${n}`),this.repo.findOneBy(e,r,...n)}async statement(t,e,...r){const{ctxArgs:i,log:n}=await this.logCtx([...r,t],this.statement);return n.info(`Running statement ${e} with args ${i}`),this.repo.statement(e,...i)}async create(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.create);i.info("CONTRACT CREATE, "+n),"string"==typeof e&&(e=this.deserialize(e)),i.info("Creating model: "+JSON.stringify(e));const s=this.getTransientData(t);return i.info("Merging transient data..."),e=a.merge(e,s,this.clazz),this.repo.create(e,...n)}async read(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.read);return i.info(`reading entry with pk ${e} `),this.repo.read(e,...n)}getTransientData(t){const e=t.stub.getTransient();let r={};return e.has(this.repo.tableName)&&(r=JSON.parse(e.get(this.repo.tableName)?.toString("utf8"))),r}async update(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.update);"string"==typeof e&&(e=this.deserialize(e)),i.info("Updating model: "+JSON.stringify(e));const s=this.getTransientData(t);return i.info("Merging transient data..."),e=a.merge(e,s,this.clazz),this.repo.update(e,...n)}async delete(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.delete);return i.info(`deleting entry with pk ${e} `),this.repo.delete(e+"",...n)}async deleteAll(t,e,...r){const{ctxArgs:i}=await this.logCtx([...r,t],this.readAll);return"string"==typeof e&&(e=JSON.parse(e)),this.repo.deleteAll(e,...i)}async readAll(t,e,...r){const{ctxArgs:i}=await this.logCtx([...r,t],this.readAll);return"string"==typeof e&&(e=JSON.parse(e)),this.repo.readAll(e,...i)}async updateAll(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.updateAll);return"string"==typeof e&&(e=JSON.parse(e).map(t=>this.deserialize(t)).map(t=>new this.clazz(t))),i.info(`updating ${e.length} entries to the table`),this.repo.updateAll(e,...n)}async query(t,e,r,i=k.ASC,n,s,...a){const{ctxArgs:o}=await this.logCtx([...a,t],this.query);return this.repo.query(e,r,i,n,s,...o)}async raw(t,e,r,...i){const{ctxArgs:n}=await this.logCtx([...i,t],this.raw);return Nt.adapter.raw(e,r,...n)}serialize(t){return Nt.serializer.serialize(t)}deserialize(t){return Nt.serializer.deserialize(t)}async init(t){const{log:e}=await this.logCtx([t],this.init);e.info(`Running contract ${this.getName()} initialization...`),this.initialized=!0,e.info("Contract initialization completed.")}async healthcheck(t){const{log:e}=await this.logCtx([t],this.healthcheck);return e.info(`Running Healthcheck: ${this.initialized}...`),{healthcheck:this.initialized}}async createAll(t,e,...r){const{log:i,ctxArgs:n}=await this.logCtx([...r,t],this.createAll);return"string"==typeof e&&(e=JSON.parse(e).map(t=>this.deserialize(t)).map(t=>new this.clazz(t))),i.info(`adding ${e.length} entries to the table`),this.repo.createAll(e,...n)}async logCtx(t,e){return Nt.logCtx.bind(this)(t,e)}static async logCtx(t,e){if(1>t.length)throw new j("No context provided");const r=t.pop();if(r instanceof ct)return{ctx:r,log:r.logger.clear().for(this).for(e),ctxArgs:[...t,r],stub:r.stub,identity:r.identity};if(!(r instanceof W))throw new j("No valid context provided");const i={correlationId:r.stub.getTxID()},n=await Nt.adapter.context((()=>{if("string"==typeof e)return e;switch(e.name){case I.CREATE:case I.READ:case I.UPDATE:case I.DELETE:case F.CREATE_ALL:case F.READ_ALL:case F.UPDATE_ALL:case F.DELETE_ALL:}return e.name})(),i,this.clazz,r),s=this?n.logger.for(this).for(e):n.logger.clear().for(this).for(e);return{ctx:n,log:s,stub:n.stub,identity:n.identity,ctxArgs:[...t,n]}}}class Rt extends Nt{constructor(t,e){super(t,e)}async create(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.create);r.info("Creating model: "+e);const n=this.deserialize(e);r.info("Model deserialized: "+JSON.stringify(n));const s=await super.create(i,n),a=this.serialize(s);return r.info("RESULT: "+JSON.stringify(s)),r.info("Retuning: "+a),a}async read(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.read);return r.info("Reading id: "+e),this.serialize(await super.read(i,e))}async update(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.update);return r.info("Updating model: "+e),this.serialize(await super.update(i,e))}async delete(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.delete);return r.info("Deleting id: "+e),this.serialize(await super.delete(i,e))}async deleteAll(t,e){const r=JSON.parse(e),{log:i,ctx:n}=await this.logCtx([t],this.deleteAll);return i.info(`deleting ${r.length} entries from the table`),JSON.stringify((await super.deleteAll(n,r)).map(t=>this.serialize(t)))}async readAll(t,e){const r=JSON.parse(e),{log:i,ctx:n}=await this.logCtx([t],this.readAll);return i.info(`reading ${r.length} entries from the table`),JSON.stringify((await super.readAll(n,r)).map(t=>this.serialize(t)))}async updateAll(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.updateAll),n=JSON.parse(e).map(t=>this.deserialize(t)).map(t=>new this.clazz(t));return r.info(`Updating ${n.length} entries to the table`),JSON.stringify((await super.updateAll(i,n)).map(t=>this.serialize(t)))}async statement(t,e,r){const{ctx:i,log:n}=await this.logCtx([t],this.statement);try{r=JSON.parse(r)}catch(t){throw new M("Invalid args: "+t)}if(!Array.isArray(r))throw new M(`Invalid args: ${JSON.stringify(r)}. must be an array`);return n.info("calling prepared statement "+e),n.info("with args "+r),JSON.stringify(await super.statement(i,e,...r))}async listBy(t,e,r){const{ctx:i,log:n}=await this.logCtx([t],this.listBy);return n.info(`Executing listBy with key ${e} and order ${r}`),JSON.stringify(await super.listBy(i,e,r))}async paginateBy(t,e,r,i,...n){const{ctx:s,log:a}=await this.logCtx([...n,t],this.paginateBy);try{i=JSON.parse(i)}catch(t){throw new M("Failed to deserialize paginateBy reference: "+t)}return a.info(`Executing paginateBy with key ${e} and order ${r}`),JSON.stringify(await super.paginateBy(s,e,r,i,...n))}async findOneBy(t,e,r,...i){const{ctx:n,log:s}=await this.logCtx([...i,t],this.findOneBy);return s.info(`Executing findOneBy with key ${e} and value ${r}`),JSON.stringify(await super.findOneBy(n,e,r,...i))}async query(t,e,r,i,n,s){const{ctx:a,log:o}=await this.logCtx([t],this.query);let c;o.info(`Executing query orderedBy ${r} and order ${i}`);try{c=x.from(JSON.parse(e))}catch(t){throw new M("Invalid condition: "+t)}return o.info("Condition: "+JSON.stringify(c)),JSON.stringify(await super.query(a,c,r,i,n,s))}async init(t){await super.init(t)}async healthcheck(t){const{log:e,ctx:r}=await this.logCtx([t],this.updateAll);return e.debug(`Running Healthcheck: ${this.initialized}...`),JSON.stringify(await super.healthcheck(r))}async createAll(t,e){const{log:r}=await this.logCtx([t],this.createAll),i=JSON.parse(e).map(t=>this.deserialize(t)).map(t=>new this.clazz(t));r.info(`Adding ${i.length} entries to the table`);const n=await super.createAll(t,i);return JSON.stringify(n.map(t=>this.serialize(t)))}}function zt(t,e){const r=t+e;if(t!==r-e||e!==r-t)throw new xt(`Addition overflow: ${t} + ${e}`);return r}function Pt(t,e){const r=t-e;if(t!==r+e||e!==t-r)throw new xt(`Subtraction overflow: ${t} - ${e}`);return r}at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"create",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"read",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"update",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"delete",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"deleteAll",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"readAll",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"updateAll",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String,String]),ot("design:returntype",Promise)],Rt.prototype,"statement",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String,String]),ot("design:returntype",Promise)],Rt.prototype,"listBy",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String,String,String,ct]),ot("design:returntype",Promise)],Rt.prototype,"paginateBy",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String,String,String]),ot("design:returntype",Promise)],Rt.prototype,"findOneBy",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Rt.prototype,"init",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Rt.prototype,"healthcheck",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Rt.prototype,"createAll",null);let Et=class extends D{constructor(t){super(t)}};at([E({type:"String"}),ot("design:type",String)],Et.prototype,"name",void 0),at([T(),u(),ot("design:type",String)],Et.prototype,"owner",void 0),at([T(),u(),ot("design:type",String)],Et.prototype,"symbol",void 0),at([T(),u(),ot("design:type",Number)],Et.prototype,"decimals",void 0),Et=at([B("erc20_tokens"),g(),ot("design:paramtypes",[Object])],Et);let Tt=class extends D{constructor(t){super(t)}};at([E({type:"String"}),ot("design:type",String)],Tt.prototype,"id",void 0),at([T(),u(),ot("design:type",String)],Tt.prototype,"token",void 0),at([T(),u(),ot("design:type",Number)],Tt.prototype,"balance",void 0),at([T(),ot("design:type",String)],Tt.prototype,"captive",void 0),Tt=at([B("erc20_wallets"),g(),ot("design:paramtypes",[Object])],Tt);let Bt=class extends D{constructor(t){super(t)}};function Dt(){return function(t,e,r){const i=r.value;return r.value=async function(...t){const r=t[0],n=r.clientIdentity.getID(),s=await this.tokenRepository.select(),a=await s.execute(r);if(0==a.length)throw new J("No tokens avaialble");if(a.length>1)throw new J("To many token available : "+a.length);if(a[0].owner!=n)throw new R(`User not authorized to run ${e} on the token`);return await i.apply(this,t)},r}}var It;at([E({type:"String"}),T(),u(),ot("design:type",String)],Bt.prototype,"owner",void 0),at([T(),u(),ot("design:type",String)],Bt.prototype,"spender",void 0),at([T(),u(),ot("design:type",Number)],Bt.prototype,"value",void 0),Bt=at([B("erc20_allowances"),g(),ot("design:paramtypes",[Object])],Bt),(t=>{t.TRANSFER="Transfer",t.APPROVAL="Approval"})(It||(It={}));class Ft extends Nt{constructor(t){super(t,Tt),Ft.adapter=Ft.adapter||new Ot,this.walletRepository=ut.forModel(Tt,Ft.adapter.alias),this.tokenRepository=ut.forModel(Et,Ft.adapter.alias),this.allowanceRepository=ut.forModel(Bt,Ft.adapter.alias)}async TokenName(t){const{ctx:e}=await this.logCtx([t],this.TokenName);await this.CheckInitialized(e);const r=this.tokenRepository.select();return(await r.execute(e))[0].name}async Symbol(t){const{ctx:e}=await this.logCtx([t],this.TokenName);await this.CheckInitialized(e);const r=this.tokenRepository.select();return(await r.execute(e))[0].symbol}async Decimals(t){const{ctx:e}=await this.logCtx([t],this.TokenName);await this.CheckInitialized(e);const r=this.tokenRepository.select();return(await r.execute(e))[0].decimals}async TotalSupply(t){const{ctx:e}=await this.logCtx([t],this.TokenName);await this.CheckInitialized(e);const r=this.walletRepository.select(),i=await r.execute(e);if(0==i.length)throw new J(`The token ${this.getName()} does not exist`);let n=0;return i.forEach(t=>{n+=t.balance}),n}async BalanceOf(t,e){const{ctx:r}=await this.logCtx([t],this.TokenName);return await this.CheckInitialized(r),(await this.walletRepository.read(e,r)).balance}async Transfer(t,e,r){const{ctx:i}=await this.logCtx([t],this.Transfer);await this.CheckInitialized(i);const n=i.identity.getID();if(!await this._transfer(n,e,r,i))throw new j("Failed to transfer");return!0}async TransferFrom(t,e,r,i){const{ctx:n}=await this.logCtx([t],this.BurnFrom);await this.CheckInitialized(n);const s=n.identity.getID(),a=await this._getAllowance(e,s,n);if(!a||0>a.value)throw new St(`spender ${s} has no allowance from ${e}`);const o=a.value;if(i>o)throw new bt("The spender does not have enough allowance to spend.");const c=Pt(o,i),l=Object.assign({},a,{value:c});if(await this.allowanceRepository.update(l,n),!await this._transfer(e,r,i,n))throw new j("Failed to transfer");return!0}async _transfer(t,e,r,i){const n=i.logger;if(t===e)throw new R("cannot transfer to and from same client account");if(0>r)throw new bt("transfer amount cannot be negative");const s=await this.walletRepository.read(t,i),a=s.balance;if(r>a)throw new bt(`client account ${t} has insufficient funds.`);let o,c=!1;try{o=await this.walletRepository.read(e,i)}catch(t){if(!(t instanceof q))throw new j(t);if(404!==t.code)throw new j(t.message);o=new Tt({id:e,balance:0,token:await this.TokenName(i)}),c=!0}const l=o.balance,u=Pt(a,r),g=zt(l,r),d=Object.assign({},s,{balance:u});await this.walletRepository.update(d,i);const h=Object.assign({},o,{balance:g});c?await this.walletRepository.create(h,i):await this.walletRepository.update(h,i);const p={from:t,to:e,value:r};return this.repo.refresh(Et,It.TRANSFER,"",p,i).catch(t=>n.error("Failed to notify transfer: "+t)),!0}async Approve(t,e,r){const{ctx:i,ctxArgs:n}=await this.logCtx([t],this.Approve);await this.CheckInitialized(i);const s=i.identity.getID();let a=await this._getAllowance(s,e,i);if((await this.walletRepository.read(s,...n)).balance<r)throw new bt(`client account ${s} has insufficient funds.`);a?(a.value=r,await this.allowanceRepository.update(a,...n)):(a=new Bt({owner:s,spender:e,value:r}),await this.allowanceRepository.create(a,...n));const o={owner:s,spender:e,value:r};return this.repo.refresh(Et,It.APPROVAL,"",o,i),!0}async Allowance(t,e,r){const{ctx:i}=await this.logCtx([t],this.Allowance);await this.CheckInitialized(i);const n=await this._getAllowance(e,r,i);if(!n)throw new St(`spender ${r} has no allowance from ${e}`);return n.value}async _getAllowance(t,e,r){const i=x.and(x.attribute("owner").eq(t),x.attribute("spender").eq(e)),n=await this.allowanceRepository.select().where(i).execute(r);return n?.[0]}async Initialize(t,e){const{ctx:r}=await this.logCtx([t],this.Initialize);if((await this.tokenRepository.select().execute(r)).length>0)throw new R("contract options are already set, client is not authorized to change them");return e.owner=r.identity.getID(),await this.tokenRepository.create(e,r),!0}async CheckInitialized(t){const{ctx:e}=await this.logCtx([t],this.CheckInitialized);if(0==(await this.tokenRepository.select().execute(e)).length)throw new At("contract options need to be set before calling any function, call Initialize() to initialize contract")}async Mint(t,e){const{ctx:r}=await this.logCtx([t],this.Mint);await this.CheckInitialized(r);const i=r.identity.getID();if(0>=e)throw new V("mint amount must be a positive integer");let n;try{n=await this.walletRepository.read(i,r);const t=zt(n.balance,e),s=Object.assign({},n,{balance:t});await this.walletRepository.update(s,r)}catch(n){if(!(n instanceof q))throw new j(n);if(404!==n.code)throw new j(n.message);{const n=new Tt({id:i,balance:e,token:await this.TokenName(t)});await this.walletRepository.create(n,r)}}const s={from:"0x0",to:i,value:e};this.repo.ObserverHandler().updateObservers(Et,It.TRANSFER,"",s,r)}async Burn(t,e){const{log:r,ctx:i}=await this.logCtx([t],this.Burn);await this.CheckInitialized(i);const n=i.identity.getID(),s=await this.walletRepository.read(n,i),a=s.balance;if(e>a)throw new bt("Minter has insufficient funds.");const o=Pt(a,e),c=Object.assign({},s,{balance:o});await this.walletRepository.update(c,i),r.info(e+" tokens were burned");const l={from:n,to:"0x0",value:e};this.repo.ObserverHandler().updateObservers(Et,It.TRANSFER,"",l,i)}async BurnFrom(t,e,r){const{log:i,ctx:n}=await this.logCtx([t],this.BurnFrom);await this.CheckInitialized(n);const s=await this.walletRepository.read(e,n),a=s.balance;if(r>a)throw new bt(e+" has insufficient funds.");const o=Pt(a,r),c=Object.assign({},s,{balance:o});await this.walletRepository.update(c,n),i.info(`${r} tokens were burned from ${e}`);const l={from:e,to:"0x0",value:r};this.repo.ObserverHandler().updateObservers(Et,It.TRANSFER,"",l,n)}async ClientAccountBalance(t){const{ctx:e}=await this.logCtx([t],this.TokenName);await this.CheckInitialized(e);const r=e.identity.getID(),i=await this.walletRepository.read(r,e);if(!i)throw new bt(`The account ${r} does not exist`);return i.balance}async ClientAccountID(t){const{ctx:e}=await this.logCtx([t],this.ClientAccountID);return await this.CheckInitialized(e),e.identity.getID()}}at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"TokenName",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"Symbol",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"Decimals",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"TotalSupply",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String]),ot("design:returntype",Promise)],Ft.prototype,"BalanceOf",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String,Number]),ot("design:returntype",Promise)],Ft.prototype,"Transfer",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String,String,Number]),ot("design:returntype",Promise)],Ft.prototype,"TransferFrom",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,String,Number]),ot("design:returntype",Promise)],Ft.prototype,"Approve",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W,String,String]),ot("design:returntype",Promise)],Ft.prototype,"Allowance",null),at([X(),ot("design:type",Function),ot("design:paramtypes",[W,Et]),ot("design:returntype",Promise)],Ft.prototype,"Initialize",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"CheckInitialized",null),at([Dt(),X(),ot("design:type",Function),ot("design:paramtypes",[W,Number]),ot("design:returntype",Promise)],Ft.prototype,"Mint",null),at([Dt(),X(),ot("design:type",Function),ot("design:paramtypes",[W,Number]),ot("design:returntype",Promise)],Ft.prototype,"Burn",null),at([Dt(),X(),ot("design:type",Function),ot("design:paramtypes",[W,String,Number]),ot("design:returntype",Promise)],Ft.prototype,"BurnFrom",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"ClientAccountBalance",null),at([X(!1),ot("design:type",Function),ot("design:paramtypes",[W]),ot("design:returntype",Promise)],Ft.prototype,"ClientAccountID",null);const qt=[Ft],jt="##VERSION##",_t="##PACKAGE##";Z.registerLibrary(_t,jt);export{ft as ContractLogger,Ot as FabricContractAdapter,ct as FabricContractContext,mt as FabricContractPaginator,ut as FabricContractRepository,lt as FabricContractRepositoryObservableHandler,Nt as FabricCrudContract,gt as FabricStatement,_t as PACKAGE_NAME,Rt as SerializedCrudContract,jt as VERSION,qt as contracts,Ct as createdByOnFabricCreateUpdate,kt as pkFabricOnCreate};
-//# sourceMappingURL=for-fabric.js.map
+import { CouchDBStatement, CouchDBKeys, CouchDBGroupOperator, CouchDBOperator, CouchDBPaginator, CouchDBAdapter } from "@decaf-ts/for-couchdb";
+
+import { Model, JSONSerializer, ModelKeys, ValidationKeys, stringFormat, required, model } from "@decaf-ts/decorator-validation";
+
+import { Context, ObserverHandler, Adapter, Repository, QueryError, PreparedStatementKeys, PersistenceKeys, Condition, Sequence, SequenceModel, Serial, UUID, PagingError, OrderDirection, AuthorizationError, UnsupportedError, MigrationError, ObserverError, ForbiddenError, ConnectionError, BaseModel, pk, column, table } from "@decaf-ts/core";
+
+import { OperationKeys, BulkCrudOperationKeys, BaseError, InternalError, DBKeys, NotFoundError, ConflictError, SerializationError, BadRequestError, onCreate, onCreateUpdate, ValidationError, readonly, onUpdate, transient, onRead, onDelete } from "@decaf-ts/db-decorators";
+
+import { Property, Object as Object$1, Contract, Context as Context$1, Transaction } from "fabric-contract-api";
+
+import { Metadata, Decoration, propMetadata, apply, metadata } from "@decaf-ts/decoration";
+
+import { MiniLogger, NumericLogLevels, LogLevel, Logging } from "@decaf-ts/logging";
+
+import { __decorate, __metadata } from "tslib";
+
+class FabricContractContext extends Context {
+    constructor() {
+        super();
+    }
+    get stub() {
+        return this.get("stub");
+    }
+    get timestamp() {
+        return this.stub.getDateTimestamp();
+    }
+    get identity() {
+        return this.get("identity");
+    }
+    toString() {
+        return `fabric ctx${this.stub ? " with stub" : "without stub"}`;
+    }
+}
+
+function generateFabricEventName(table, event, owner) {
+    const params = [ table, event ];
+    if (owner) params.push(owner);
+    return params.join("_");
+}
+
+function parseEventName(name) {
+    const parts = name.split("_");
+    if (parts.length < 2 || parts.length > 3) return {
+        table: undefined,
+        event: name,
+        owner: undefined
+    };
+    return {
+        table: parts[0],
+        event: parts[1],
+        owner: parts[2]
+    };
+}
+
+class FabricContractRepositoryObservableHandler extends ObserverHandler {
+    constructor(supportedEvents = [ OperationKeys.CREATE, OperationKeys.UPDATE, OperationKeys.DELETE, BulkCrudOperationKeys.CREATE_ALL, BulkCrudOperationKeys.UPDATE_ALL, BulkCrudOperationKeys.DELETE_ALL ]) {
+        super();
+        this.supportedEvents = supportedEvents;
+    }
+    async updateObservers(clazz, event, id, ...args) {
+        const {log: log, ctx: ctx} = Adapter.logCtx(args, this.updateObservers);
+        const {stub: stub} = ctx;
+        const [owner, payload] = args;
+        const table = typeof clazz === "string" ? clazz : clazz.name;
+        if (this.supportedEvents.indexOf(event) !== -1) {
+            log.debug(`Emitting ${event} event`);
+            const eventName = generateFabricEventName(table, event, owner);
+            stub.setEvent(eventName, Buffer.from(JSON.stringify({
+                id: id
+            })));
+        } else {
+            stub.setEvent(event, Buffer.from(JSON.stringify(payload)));
+        }
+    }
+}
+
+class FabricContractRepository extends Repository {
+    constructor(adapter, clazz, trackedEvents) {
+        super(adapter, clazz);
+        this.trackedEvents = trackedEvents;
+        this._overrides = Object.assign({}, super["_overrides"], {
+            ignoreValidation: false,
+            ignoreHandlers: false,
+            allowRawStatements: true,
+            forcePrepareSimpleQueries: false,
+            forcePrepareComplexQueries: false
+        });
+    }
+    async paginateBy(key, order, ref = {
+        offset: 1,
+        limit: 10
+    }, ...args) {
+        let {offset: offset, bookmark: bookmark, limit: limit} = ref;
+        if (!offset && !bookmark) throw new QueryError(`PaginateBy needs a page or a bookmark`);
+        const contextArgs = await Context.args(PreparedStatementKeys.PAGE_BY, this.class, args, this.adapter, this._overrides || {});
+        const {log: log, ctxArgs: ctxArgs} = this.logCtx(contextArgs.args, this.paginateBy);
+        log.verbose(`paginating ${Model.tableName(this.class)} with page size ${limit}`);
+        let paginator;
+        if (bookmark) {
+            paginator = await this.override({
+                forcePrepareComplexQueries: false,
+                forcePrepareSimpleQueries: false
+            }).select().where(this.attr(Model.pk(this.class)).gt(bookmark)).orderBy([ key, order ]).paginate(limit, ...ctxArgs);
+            offset = 1;
+        } else if (offset) {
+            paginator = await this.override({
+                forcePrepareComplexQueries: false,
+                forcePrepareSimpleQueries: false
+            }).select().orderBy([ key, order ]).paginate(limit, ...ctxArgs);
+        } else {
+            throw new QueryError(`PaginateBy needs a page or a bookmark`);
+        }
+        const paged = await paginator.page(offset, ...ctxArgs);
+        return paginator.serialize(paged);
+    }
+    async statement(name, ...args) {
+        if (!Repository.statements(this, name)) throw new QueryError(`Invalid prepared statement requested ${name}`);
+        const contextArgs = await Context.args(PersistenceKeys.STATEMENT, this.class, args, this.adapter, this._overrides || {});
+        if (contextArgs.context.logger) {
+            contextArgs.context.logger.info(`Repo statement: ${name} + ${args}`);
+        }
+        const {log: log, ctxArgs: ctxArgs} = this.logCtx(contextArgs.args, this.statement);
+        log.verbose(`Executing prepared statement ${name} with args ${ctxArgs}`);
+        let result;
+        try {
+            result = await this[name](...ctxArgs);
+        } catch (e) {
+            if (e instanceof BaseError) throw e;
+            throw new InternalError(`Failed to execute prepared statement ${name} with args ${ctxArgs}: ${e}`);
+        }
+        return result;
+    }
+    ObserverHandler() {
+        return new FabricContractRepositoryObservableHandler;
+    }
+    async updateObservers(table, event, id, ...args) {
+        if (!this.trackedEvents || this.trackedEvents.indexOf(event) !== -1) return await super.updateObservers(table, event, id, ...args);
+    }
+}
+
+class FabricStatement extends CouchDBStatement {
+    constructor(adapter) {
+        super(adapter);
+    }
+    async raw(rawInput, ...args) {
+        const {ctx: ctx} = this.logCtx(args, this.raw);
+        const results = await this.adapter.raw(rawInput, true, ctx);
+        const pkAttr = Model.pk(this.fromSelector);
+        const type = Metadata.get(this.fromSelector, Metadata.key(DBKeys.ID, pkAttr))?.type;
+        if (!this.selectSelector) return results.map(r => this.processRecord(r, pkAttr, type, ctx));
+        return results;
+    }
+    build() {
+        const selectors = {};
+        selectors[CouchDBKeys.TABLE] = {};
+        selectors[CouchDBKeys.TABLE] = Model.tableName(this.fromSelector);
+        const query = {
+            selector: selectors
+        };
+        if (this.selectSelector) query.fields = this.selectSelector;
+        if (this.whereCondition) {
+            const condition = this.parseCondition(Condition.and(this.whereCondition, Condition.attribute(CouchDBKeys.TABLE).eq(query.selector[CouchDBKeys.TABLE]))).selector;
+            const selectorKeys = Object.keys(condition);
+            if (selectorKeys.length === 1 && Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1) switch (selectorKeys[0]) {
+              case CouchDBGroupOperator.AND:
+                condition[CouchDBGroupOperator.AND] = [ ...Object.values(condition[CouchDBGroupOperator.AND]).reduce((accum, val) => {
+                    const keys = Object.keys(val);
+                    if (keys.length !== 1) throw new Error("Too many keys in query selector. should be one");
+                    const k = keys[0];
+                    if (k === CouchDBGroupOperator.AND) accum.push(...val[k]); else accum.push(val);
+                    return accum;
+                }, []) ];
+                query.selector = condition;
+                break;
+
+              case CouchDBGroupOperator.OR:
+                {
+                    const s = {};
+                    s[CouchDBGroupOperator.AND] = [ condition, ...Object.entries(query.selector).map(([key, val]) => {
+                        const result = {};
+                        result[key] = val;
+                        return result;
+                    }) ];
+                    query.selector = s;
+                    break;
+                }
+
+              default:
+                throw new Error("This should be impossible");
+            } else {
+                Object.entries(condition).forEach(([key, val]) => {
+                    if (query.selector[key]) console.warn(`A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`);
+                    query.selector[key] = val;
+                });
+            }
+        }
+        if (this.orderBySelector) {
+            query.sort = query.sort || [];
+            query.selector = query.selector || {};
+            const [selector, value] = this.orderBySelector;
+            const rec = {};
+            rec[selector] = value;
+            query.sort.push(rec);
+            if (!query.selector[selector]) {
+                query.selector[selector] = {};
+                query.selector[selector][CouchDBOperator.BIGGER] = null;
+            }
+        }
+        if (this.limitSelector) query.limit = this.limitSelector;
+        if (this.offsetSelector) query.skip = this.offsetSelector;
+        return query;
+    }
+}
+
+class FabricContractSequence extends Sequence {
+    constructor(options, adapter) {
+        super(options, adapter);
+    }
+    async current(...args) {
+        const contextArgs = await Context.args(OperationKeys.READ, SequenceModel, args, this.adapter);
+        const ctx = contextArgs.context;
+        const {name: name, startWith: startWith} = this.options;
+        try {
+            const sequence = await this.repo.read(name, ctx);
+            return this.parse(sequence.current);
+        } catch (e) {
+            const log = ctx.logger.for(this.current);
+            if (e instanceof NotFoundError) {
+                let cachedCurrent;
+                try {
+                    log.debug(`Trying to resolve current sequence ${name} value from context`);
+                    cachedCurrent = ctx.get(name);
+                    log.debug(`Retrieved cached current value for sequence ${name}: ${cachedCurrent}`);
+                } catch (e) {
+                    log.info(`No cached value for sequence ${name} in context`);
+                    cachedCurrent = startWith;
+                }
+                try {
+                    return this.parse(cachedCurrent);
+                } catch (e) {
+                    throw new InternalError(`Failed to parse initial value for sequence ${startWith}: ${e}`);
+                }
+            }
+            throw new InternalError(`Failed to retrieve current value for sequence ${name}: ${e}`);
+        }
+    }
+    async increment(count, ctx) {
+        const log = ctx.logger.for(this.increment);
+        const {type: type, incrementBy: incrementBy, name: name} = this.options;
+        if (!name) throw new InternalError("Sequence name is required");
+        log.info(`Obtaining sequence lock for sequence ${name}`);
+        return FabricContractSequence.lock.execute(async () => {
+            const toIncrementBy = count || incrementBy;
+            if (toIncrementBy % incrementBy !== 0) throw new InternalError(`Value to increment does not consider the incrementBy setting: ${incrementBy}`);
+            const typeName = typeof type === "function" && type?.name ? type.name : type;
+            const currentValue = await this.current(ctx);
+            async function returnAndCache(res) {
+                if (res instanceof Promise) res = await res;
+                ctx.logger.for(returnAndCache).info(`Storing new ${name} seq value in cache: ${res.current}`);
+                ctx.cache.put(name, res.current);
+                return res;
+            }
+            const performUpsert = async next => {
+                try {
+                    return await returnAndCache(this.repo.update(new SequenceModel({
+                        id: name,
+                        current: next
+                    }), ctx));
+                } catch (e) {
+                    if (e instanceof NotFoundError) {
+                        log.debug(`Sequence create ${name} current=${currentValue} next=${next}`);
+                        return returnAndCache(this.repo.create(new SequenceModel({
+                            id: name,
+                            current: next
+                        }), ctx));
+                    }
+                    throw e;
+                }
+            };
+            const incrementSerial = base => {
+                switch (typeName) {
+                  case Number.name:
+                    return this.parse(base) + toIncrementBy;
+
+                  case BigInt.name:
+                    return this.parse(base) + BigInt(toIncrementBy);
+
+                  case String.name:
+                    return this.parse(base);
+
+                  case "serial":
+                    return Serial.instance.generate(base);
+
+                  default:
+                    throw new InternalError("Should never happen");
+                }
+            };
+            if (typeName === "uuid") {
+                while (true) {
+                    const next = UUID.instance.generate(currentValue);
+                    try {
+                        const result = await performUpsert(next);
+                        log.debug(`Sequence uuid increment ${name} current=${currentValue} next=${next}`);
+                        return result.current;
+                    } catch (e) {
+                        if (e instanceof ConflictError) continue;
+                        throw e;
+                    }
+                }
+            }
+            const next = incrementSerial(currentValue);
+            const seq = await performUpsert(next);
+            log.debug(`Sequence.increment ${name} current=${currentValue} next=${next}`);
+            return seq.current;
+        }, name);
+    }
+}
+
+var FabricModelKeys;
+
+(function(FabricModelKeys) {
+    FabricModelKeys["PRIVATE"] = "private";
+    FabricModelKeys["SHARED"] = "shared";
+    FabricModelKeys["FABRIC"] = "fabric.";
+    FabricModelKeys["OWNEDBY"] = "owned-by";
+    FabricModelKeys["TRANSACTION_ID"] = "transaction-id";
+})(FabricModelKeys || (FabricModelKeys = {}));
+
+var IdentityType;
+
+(function(IdentityType) {
+    IdentityType["X509"] = "X.509";
+})(IdentityType || (IdentityType = {}));
+
+const FabricFlavour = "hlf-fabric";
+
+class SimpleDeterministicSerializer extends JSONSerializer {
+    constructor() {
+        super();
+    }
+    deserialize(str, tableName) {
+        const deserialization = JSON.parse(str);
+        return deserialization;
+    }
+    serialize(model, putAnchor = true) {
+        const stringify = require("json-stringify-deterministic");
+        const sortKeysRecursive = require("sort-keys-recursive");
+        const preSerialization = this.preSerialize(model, putAnchor);
+        return stringify(sortKeysRecursive(preSerialization));
+    }
+    preSerialize(model, putAnchor = true) {
+        const toSerialize = Object.assign({}, model);
+        let metadata;
+        try {
+            metadata = Metadata.modelName(model.constructor);
+        } catch (error) {
+            metadata = undefined;
+        }
+        if (putAnchor) toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;
+        function preSerialize(obj) {
+            if (typeof obj !== "object") return obj;
+            if (Array.isArray(obj)) return obj.map(preSerialize);
+            return this.preSerialize(obj);
+        }
+        Model.relations(model).forEach(r => {
+            toSerialize[r] = preSerialize.call(this, toSerialize[r]);
+        });
+        return toSerialize;
+    }
+}
+
+class ContractLogger extends MiniLogger {
+    constructor(context, conf, ctx) {
+        super(context, conf);
+        if (!ctx) {
+            this.logger = new MiniLogger(context, conf);
+        } else {
+            this.logger = ctx.logging.getLogger(context);
+        }
+    }
+    log(level, msg, stack) {
+        if (NumericLogLevels[this.config("level")] < NumericLogLevels[level]) return;
+        let method;
+        switch (level) {
+          case LogLevel.info:
+            method = this.logger.info;
+            break;
+
+          case LogLevel.verbose:
+            method = this.logger.verbose;
+            break;
+
+          case LogLevel.debug:
+            method = this.logger.debug;
+            break;
+
+          case LogLevel.error:
+            method = this.logger.error;
+            break;
+
+          case LogLevel.warn:
+            method = this.logger.warn;
+            break;
+
+          case LogLevel.silly:
+            method = this.logger.silly;
+            break;
+
+          default:
+            throw new InternalError("Invalid log level");
+        }
+        method.call(this.logger, this.createLog(level, msg, stack));
+    }
+}
+
+const factory = (object, config, ctx) => new ContractLogger(object || ContractLogger.name, config || {}, ctx);
+
+Logging.setFactory(factory);
+
+class FabricContractPaginator extends CouchDBPaginator {
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
+    }
+    prepare(rawStatement) {
+        const query = Object.assign({}, rawStatement);
+        if (query.limit) this.limit = query.limit;
+        query.limit = this.size;
+        return query;
+    }
+    async page(page = 1, ...args) {
+        const {ctxArgs: ctxArgs, ctx: ctx} = this.adapter["logCtx"](args, this.page);
+        if (this.isPreparedStatement()) return this.pagePrepared(page, ...ctxArgs);
+        const statement = Object.assign({}, this.statement);
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+            const results = await this.adapter.raw({
+                ...statement,
+                limit: undefined
+            }, true, ctx) || [];
+            this._recordCount = results.length;
+            if (this._recordCount > 0) {
+                const size = statement?.limit || this.size;
+                this._totalPages = Math.ceil(this._recordCount / size);
+            }
+        }
+        this.validatePage(page);
+        if (page !== 1) {
+            if (!this._bookmark) throw new PagingError("No bookmark. Did you start in the first page?");
+            statement["bookmark"] = this._bookmark;
+        }
+        const docs = await this.adapter.raw(statement, false, ctx);
+        if (!this.clazz) throw new PagingError("No statement target defined");
+        const id = Model.pk(this.clazz);
+        const type = Metadata.get(this.clazz, Metadata.key(DBKeys.ID, id))?.type;
+        const results = statement.fields && statement.fields.length ? docs : docs.map(d => this.adapter.revert(d, this.clazz, Sequence.parseValue(type, d[id]), undefined, ctx));
+        const direction = statement.sort?.[0] || OrderDirection.DSC;
+        this._bookmark = results[direction === OrderDirection.ASC ? results.length - 1 : 0][id];
+        this._currentPage = page;
+        return results;
+    }
+}
+
+class OverflowError extends InternalError {
+    constructor(msg) {
+        super(msg, OverflowError.name);
+    }
+}
+
+class BalanceError extends InternalError {
+    constructor(msg) {
+        super(msg, BalanceError.name);
+    }
+}
+
+class AllowanceError extends InternalError {
+    constructor(msg) {
+        super(msg, AllowanceError.name);
+    }
+}
+
+class RegistrationError extends AuthorizationError {
+    constructor(msg) {
+        super(msg, RegistrationError.name);
+    }
+}
+
+class MissingContextError extends InternalError {
+    constructor(msg) {
+        super(msg, MissingContextError.name, 500);
+    }
+}
+
+class UnauthorizedPrivateDataAccess extends BaseError {
+    constructor(msg = "MISSING_PRIVATE_DATA_ERROR_MESSAGE") {
+        super(UnauthorizedPrivateDataAccess.name, msg, 403);
+    }
+}
+
+class NotInitializedError extends BaseError {
+    constructor(msg) {
+        super(NotInitializedError.name, msg, 409);
+    }
+}
+
+class MissingPKCSS11Lib extends InternalError {
+    constructor(msg) {
+        super(msg, MissingPKCSS11Lib.name, 500);
+    }
+}
+
+class EndorsementError extends InternalError {
+    constructor(message) {
+        super(message, EndorsementError.name, 500);
+    }
+}
+
+class MvccReadConflictError extends InternalError {
+    constructor(message) {
+        super(message, MvccReadConflictError.name, 500);
+    }
+}
+
+class PhantomReadConflictError extends InternalError {
+    constructor(message) {
+        super(message, PhantomReadConflictError.name, 500);
+    }
+}
+
+class EndorsementPolicyError extends InternalError {
+    constructor(message) {
+        super(message, EndorsementPolicyError.name, 500);
+    }
+}
+
+async function createdByOnFabricCreateUpdate(context, data, key, model) {
+    try {
+        const user = context.get("identity");
+        model[key] = user.getID();
+    } catch (e) {
+        throw new UnsupportedError("No User found in context. Please provide a user in the context");
+    }
+}
+
+async function pkFabricOnCreate(context, data, key, model) {
+    if (!data.type || model[key]) {
+        return;
+    }
+    const setPrimaryKeyValue = function(target, propertyKey, value) {
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            writable: false,
+            configurable: true,
+            value: value
+        });
+    };
+    if (!data.name) data.name = Model.sequenceName(model, "pk");
+    let sequence;
+    try {
+        sequence = await this.adapter.Sequence(data);
+    } catch (e) {
+        throw new InternalError(`Failed to instantiate Sequence ${data.name}: ${e}`);
+    }
+    const next = await sequence.next(context);
+    setPrimaryKeyValue(model, key, next);
+}
+
+class FabricContractAdapter extends CouchDBAdapter {
+    getClient() {
+        throw new UnsupportedError("Client is not supported in Fabric contracts");
+    }
+    static {
+        this.textDecoder = new TextDecoder("utf8");
+    }
+    static {
+        this.serializer = new SimpleDeterministicSerializer;
+    }
+    repository() {
+        return FabricContractRepository;
+    }
+    Paginator(query, size, clazz) {
+        return new FabricContractPaginator(this, query, size, clazz);
+    }
+    async Sequence(options) {
+        return new FabricContractSequence(options, this);
+    }
+    constructor(scope, alias) {
+        super(scope, FabricFlavour, alias);
+        this.Context = FabricContractContext;
+    }
+    for(config, ...args) {
+        return super.for(config, ...args);
+    }
+    async create(clazz, id, model, ...args) {
+        const {ctx: ctx, log: log} = this.logCtx(args, this.create);
+        log.info(`in ADAPTER create with args ${args}`);
+        const tableName = Model.tableName(clazz);
+        try {
+            log.info(`adding entry to ${tableName} table with pk ${id}`);
+            const composedKey = ctx.stub.createCompositeKey(tableName, [ String(id) ]);
+            model = await this.putState(composedKey, model, ctx);
+        } catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    async read(clazz, id, ...args) {
+        const {ctx: ctx, log: log} = this.logCtx(args, this.read);
+        log.info(`in ADAPTER read with args ${args}`);
+        const tableName = Model.tableName(clazz);
+        let model;
+        try {
+            const composedKey = ctx.stub.createCompositeKey(tableName, [ String(id) ]);
+            model = await this.readState(composedKey, ctx);
+        } catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    async update(clazz, id, model, ...args) {
+        const {ctx: ctx, log: log} = this.logCtx(args, this.update);
+        const tableName = Model.tableName(clazz);
+        try {
+            log.verbose(`updating entry to ${tableName} table with pk ${id}`);
+            const composedKey = ctx.stub.createCompositeKey(tableName, [ String(id) ]);
+            model = await this.putState(composedKey, model, ctx);
+        } catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    async delete(clazz, id, ...args) {
+        const {ctx: ctx, log: log, ctxArgs: ctxArgs} = this.logCtx(args, this.delete);
+        const tableName = Model.tableName(clazz);
+        let model;
+        try {
+            const composedKey = ctx.stub.createCompositeKey(tableName, [ String(id) ]);
+            model = await this.read(clazz, id, ...ctxArgs);
+            log.verbose(`deleting entry with pk ${id} from ${tableName} table`);
+            await this.deleteState(composedKey, ctx);
+        } catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    async deleteState(id, context) {
+        const {ctx: ctx} = this.logCtx([ context ], this.deleteState);
+        await ctx.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":
+                            {
+                                const [stub, id, model] = argsList;
+                                await stub.putPrivateData(collection, id.toString(), model);
+                                return model;
+                            }
+
+                          case "deleteState":
+                            {
+                                const [stub, id] = argsList;
+                                return stub.deletePrivateData(collection, id);
+                            }
+
+                          case "readState":
+                            {
+                                const [stub, id] = argsList;
+                                return stub.getPrivateData(collection, id);
+                            }
+
+                          case "queryResult":
+                            {
+                                const [stub, rawInput] = argsList;
+                                return stub.getPrivateDataQueryResult(collection, rawInput);
+                            }
+
+                          case "queryResultPaginated":
+                            {
+                                const [stub, rawInput, limit, skip] = argsList;
+                                const iterator = await stub.getPrivateDataQueryResult(collection, rawInput);
+                                const results = [];
+                                let count = 0;
+                                let reachedBookmark = skip ? false : true;
+                                let lastKey = null;
+                                while (true) {
+                                    const res = await iterator.next();
+                                    if (res.value && res.value.value.toString()) {
+                                        const recordKey = res.value.key;
+                                        const recordValue = res.value.value.toString("utf8");
+                                        if (!reachedBookmark) {
+                                            if (recordKey === skip?.toString()) {
+                                                reachedBookmark = true;
+                                            }
+                                            continue;
+                                        }
+                                        results.push({
+                                            Key: recordKey,
+                                            Record: JSON.parse(recordValue)
+                                        });
+                                        lastKey = recordKey;
+                                        count++;
+                                        if (count >= limit) {
+                                            await iterator.close();
+                                            return {
+                                                iterator: results,
+                                                metadata: {
+                                                    fetchedRecordsCount: results.length,
+                                                    bookmark: lastKey
+                                                }
+                                            };
+                                        }
+                                    }
+                                    if (res.done) {
+                                        await iterator.close();
+                                        return {
+                                            iterator: results,
+                                            metadata: {
+                                                fetchedRecordsCount: results.length,
+                                                bookmark: ""
+                                            }
+                                        };
+                                    }
+                                }
+                            }
+
+                          default:
+                            throw new InternalError(`Unsupported method override ${String(prop)}`);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    async putState(id, model, ctx) {
+        let data;
+        const {log: log} = this.logCtx([ ctx ], this.putState);
+        try {
+            data = Buffer.from(FabricContractAdapter.serializer.serialize(model, false));
+        } catch (e) {
+            throw new SerializationError(`Failed to serialize record with id ${id}: ${e}`);
+        }
+        const collection = ctx.get("segregated");
+        if (collection) await ctx.stub.putPrivateData(collection, id.toString(), data); else await ctx.stub.putState(id.toString(), data);
+        log.silly(`state stored${collection ? ` in ${collection} collection` : ""} under id ${id}`);
+        return model;
+    }
+    async readState(id, ctx) {
+        let result;
+        const {log: log} = this.logCtx([ ctx ], this.readState);
+        let res;
+        const collection = ctx.get("segregated");
+        if (collection) res = (await ctx.stub.getPrivateData(collection, id.toString())).toString(); else res = (await ctx.stub.getState(id.toString())).toString();
+        if (!res) throw new NotFoundError(`Record with id ${id}${collection ? ` in ${collection} collection` : ""} not found`);
+        log.silly(`state retrieved from${collection ? ` ${collection} collection` : ""} under id ${id}`);
+        try {
+            result = FabricContractAdapter.serializer.deserialize(res.toString());
+        } catch (e) {
+            throw new SerializationError(`Failed to parse record: ${e}`);
+        }
+        return result;
+    }
+    async queryResult(stub, rawInput, ...args) {
+        const {ctx: ctx} = this.logCtx(args, this.readState);
+        let res;
+        const collection = ctx.get("segregated");
+        if (collection) res = await ctx.stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput)); else res = await stub.getQueryResult(JSON.stringify(rawInput));
+        return res;
+    }
+    async queryResultPaginated(stub, rawInput, limit = 250, skip, ...args) {
+        const {ctx: ctx} = this.logCtx(args, this.readState);
+        let res;
+        const collection = ctx.get("segregated");
+        if (collection) {
+            rawInput.selector = {
+                ...rawInput.selector,
+                _id: skip ? {
+                    $gt: skip.toString()
+                } : {
+                    $gte: ""
+                }
+            };
+            const it = await stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
+            res = {
+                iterator: it,
+                metadata: {
+                    fetchedRecordsCount: limit,
+                    bookmark: ""
+                }
+            };
+        } else res = await stub.getQueryResultWithPagination(JSON.stringify(rawInput), limit, skip?.toString());
+        return res;
+    }
+    mergeModels(results) {
+        const extract = model => Object.entries(model).reduce((accum, [key, val]) => {
+            if (typeof val !== "undefined") accum[key] = val;
+            return accum;
+        }, {});
+        let finalModel = results.pop();
+        for (const res of results) {
+            finalModel = Object.assign({}, extract(finalModel), extract(res));
+        }
+        return finalModel;
+    }
+    decode(buffer) {
+        return FabricContractAdapter.textDecoder.decode(buffer);
+    }
+    async flags(operation, model, flags, ctx, ...args) {
+        const baseFlags = {
+            stub: ctx.stub,
+            segregated: false
+        };
+        if (ctx instanceof FabricContractContext) {
+            Object.assign(baseFlags, {
+                logger: ctx.logger,
+                identity: ctx.identity,
+                correlationId: ctx.stub.getTxID()
+            });
+        } else {
+            Object.assign(baseFlags, {
+                identity: ctx.clientIdentity,
+                logger: new ContractLogger(this, undefined, ctx),
+                correlationId: ctx.stub.getTxID()
+            });
+        }
+        flags = await super.flags(operation, model, baseFlags, ...args);
+        return flags;
+    }
+    index(models) {
+        return Promise.resolve(undefined);
+    }
+    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) {
+                    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`);
+        iterator.close();
+        return allResults;
+    }
+    async raw(rawInput, docsOnly = true, ...args) {
+        const {log: log, stub: stub, ctx: ctx} = this.logCtx(args, this.raw);
+        const {skip: skip, limit: limit} = rawInput;
+        let iterator;
+        if (limit || skip) {
+            delete rawInput["limit"];
+            delete rawInput["skip"];
+            log.debug(`Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`);
+            const response = await this.queryResultPaginated(stub, rawInput, limit || 250, skip?.toString(), ctx);
+            iterator = response.iterator;
+        } else {
+            log.debug("Retrieving iterator");
+            iterator = await this.queryResult(stub, rawInput, ctx);
+        }
+        log.debug("Iterator acquired");
+        const results = await this.resultIterator(log, iterator);
+        log.debug(`returning ${Array.isArray(results) ? results.length : 1} results`);
+        return results;
+    }
+    Statement() {
+        return new FabricStatement(this);
+    }
+    async createAll(tableName, id, model, ...args) {
+        if (id.length !== model.length) throw new InternalError("Ids and models must have the same length");
+        const {log: log, ctxArgs: ctxArgs} = this.logCtx(args, this.createAll);
+        const tableLabel = 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)));
+    }
+    async updateAll(tableName, id, model, ...args) {
+        if (id.length !== model.length) throw new InternalError("Ids and models must have the same length");
+        const {log: log, ctxArgs: ctxArgs} = this.logCtx(args, this.updateAll);
+        const tableLabel = 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)));
+    }
+    prepare(model, ...args) {
+        const {log: log} = this.logCtx(args, this.prepare);
+        const tableName = Model.tableName(model.constructor);
+        const pk = Model.pk(model.constructor);
+        const split = Model.segregate(model);
+        const result = Object.entries(split.model).reduce((accum, [key, val]) => {
+            if (typeof val === "undefined") return accum;
+            const mappedProp = Model.columnName(model, key);
+            if (this.isReserved(mappedProp)) throw new InternalError(`Property name ${mappedProp} is reserved`);
+            accum[mappedProp] = val;
+            return accum;
+        }, {});
+        log.silly(`Preparing record for ${tableName} table with pk ${model[pk]}`);
+        return {
+            record: result,
+            id: model[pk],
+            transient: split.transient
+        };
+    }
+    revert(obj, clazz, id, transient, ...args) {
+        const {log: log} = this.logCtx(args, this.revert);
+        const ob = {};
+        const pk = Model.pk(clazz);
+        ob[pk] = id;
+        const m = typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob);
+        log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
+        const result = Object.keys(m).reduce((accum, key) => {
+            accum[key] = obj[Model.columnName(accum, key)];
+            return accum;
+        }, m);
+        if (transient) {
+            log.debug(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+            Object.entries(transient).forEach(([key, val]) => {
+                if (key in result && result[key] !== undefined) throw new InternalError(`Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`);
+                result[key] = val;
+            });
+        }
+        return result;
+    }
+    createPrefix(tableName, id, model, ...args) {
+        const {ctxArgs: ctxArgs} = this.logCtx(args, this.createPrefix);
+        const record = {};
+        record[CouchDBKeys.TABLE] = Model.tableName(tableName);
+        Object.assign(record, model);
+        return [ tableName, id, record, ...ctxArgs ];
+    }
+    updatePrefix(tableName, id, model, ...args) {
+        const {ctxArgs: ctxArgs} = this.logCtx(args, this.updatePrefix);
+        const record = {};
+        record[CouchDBKeys.TABLE] = Model.tableName(tableName);
+        Object.assign(record, model);
+        return [ tableName, id, record, ...ctxArgs ];
+    }
+    createAllPrefix(tableName, ids, models, ...args) {
+        if (ids.length !== models.length) throw new InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[CouchDBKeys.TABLE] = 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 InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[CouchDBKeys.TABLE] = 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, method) {
+        return FabricContractAdapter.logCtx.call(this, args, method);
+    }
+    static logCtx(args, method) {
+        if (args.length < 1) throw new InternalError("No context provided");
+        const ctx = args.pop();
+        if (!(ctx instanceof Context)) throw new InternalError("No context provided");
+        if (args.filter(a => a instanceof Context).length > 1) throw new Error("here");
+        const log = this ? ctx.logger.for(this).for(method) : ctx.logger.clear().for(this).for(method);
+        return {
+            ctx: ctx,
+            log: method ? log.for(method) : log,
+            stub: ctx.stub,
+            identity: ctx.identity,
+            ctxArgs: [ ...args, ctx ]
+        };
+    }
+    static parseError(err) {
+        const msg = typeof err === "string" ? err : err.message;
+        if (msg.includes(NotFoundError.name)) return new NotFoundError(err);
+        if (msg.includes(ConflictError.name)) return new ConflictError(err);
+        if (msg.includes(BadRequestError.name)) return new BadRequestError(err);
+        if (msg.includes(QueryError.name)) return new QueryError(err);
+        if (msg.includes(PagingError.name)) return new PagingError(err);
+        if (msg.includes(UnsupportedError.name)) return new UnsupportedError(err);
+        if (msg.includes(MigrationError.name)) return new MigrationError(err);
+        if (msg.includes(ObserverError.name)) return new ObserverError(err);
+        if (msg.includes(AuthorizationError.name)) return new AuthorizationError(err);
+        if (msg.includes(ForbiddenError.name)) return new ForbiddenError(err);
+        if (msg.includes(ConnectionError.name)) return new ConnectionError(err);
+        if (msg.includes(SerializationError.name)) return new SerializationError(err);
+        if (msg.includes("no ledger context")) return new MissingContextError(`No context found. this can be caused by debugging: ${msg}`);
+        return new InternalError(err);
+    }
+    static decoration() {
+        super.decoration();
+        Decoration.flavouredAs(FabricFlavour).for(PersistenceKeys.CREATED_BY).define(onCreate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.CREATED_BY, {})).apply();
+        Decoration.flavouredAs(FabricFlavour).for(PersistenceKeys.UPDATED_BY).define(onCreateUpdate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.UPDATED_BY, {})).apply();
+        Decoration.flavouredAs(FabricFlavour).for(PersistenceKeys.COLUMN).extend(Property()).apply();
+        Decoration.flavouredAs(FabricFlavour).for(ValidationKeys.DATE).extend(function fabricProperty() {
+            return (target, prop) => {
+                Property(prop, "string:date")(target, prop);
+            };
+        });
+        Decoration.flavouredAs(FabricFlavour).for(PersistenceKeys.TABLE).extend(function table(obj) {
+            const chain = [];
+            let current = typeof obj === "function" ? Metadata.constr(obj) : 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));
+            while (chain.length > 0) {
+                const constructor = chain.pop();
+                console.log(`Calling on ${constructor.name}`);
+                Object$1()(constructor);
+            }
+            return Object$1()(obj);
+        }).apply();
+    }
+}
+
+FabricContractAdapter.decoration();
+
+Adapter.setCurrent(FabricFlavour);
+
+class DeterministicSerializer extends JSONSerializer {
+    constructor() {
+        super();
+    }
+    preSerialize(model) {
+        const toSerialize = Object.assign({}, model);
+        let metadata;
+        try {
+            metadata = Metadata.modelName(model.constructor);
+        } catch (error) {
+            metadata = undefined;
+        }
+        toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;
+        const preSerialize = function preSerialize(obj) {
+            const self = this;
+            if (typeof obj !== "object") return obj;
+            if (Array.isArray(obj)) return obj.map(o => preSerialize.call(self, o));
+            return this.preSerialize.call(this, obj);
+        }.bind(this);
+        Model.relations(model).forEach(r => {
+            toSerialize[r] = preSerialize(toSerialize[r]);
+        });
+        return toSerialize;
+    }
+    deserialize(str) {
+        const deserialization = JSON.parse(str);
+        const className = deserialization[ModelKeys.ANCHOR];
+        if (!className) throw new Error("Could not find class reference in serialized model");
+        const model = Model.build(deserialization, className);
+        return model;
+    }
+    serialize(model) {
+        const stringify = require("json-stringify-deterministic");
+        const sortKeysRecursive = require("sort-keys-recursive");
+        return stringify(sortKeysRecursive(this.preSerialize(model)));
+    }
+}
+
+Object$1()(Date);
+
+class FabricCrudContract extends Contract {
+    static {
+        this.adapter = new FabricContractAdapter;
+    }
+    static {
+        this.serializer = new DeterministicSerializer;
+    }
+    constructor(name, clazz) {
+        super(name);
+        this.clazz = clazz;
+        this.initialized = false;
+        this.repo = Repository.forModel(clazz);
+    }
+    async listBy(ctx, key, order, ...args) {
+        const {ctxArgs: ctxArgs, log: log} = await this.logCtx([ ...args, ctx ], this.listBy);
+        log.info(`Running listBy key ${key}, order ${order} and args ${ctxArgs}`);
+        return this.repo.listBy(key, order, ...ctxArgs);
+    }
+    async paginateBy(ctx, key, order, ref = {
+        offset: 1,
+        limit: 10
+    }, ...args) {
+        const {ctxArgs: ctxArgs, log: log} = await this.logCtx([ ...args, ctx ], this.paginateBy);
+        log.info(`Running paginateBy key ${key}, order ${order} with size ${ref.limit} and args ${ctxArgs}`);
+        return this.repo.paginateBy(key, order, ref, ...ctxArgs);
+    }
+    async findOneBy(ctx, key, value, ...args) {
+        const {ctxArgs: ctxArgs, log: log} = await this.logCtx([ ...args, ctx ], this.findOneBy);
+        log.info(`Running findOneBy key ${key}, value: ${value} with args ${ctxArgs}`);
+        return this.repo.findOneBy(key, value, ...ctxArgs);
+    }
+    async statement(ctx, method, ...args) {
+        const {ctxArgs: ctxArgs, log: log} = await this.logCtx([ ...args, ctx ], this.statement);
+        log.info(`Running statement ${method} with args ${ctxArgs}`);
+        return this.repo.statement(method, ...ctxArgs);
+    }
+    async create(ctx, model, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.create);
+        log.info(`CONTRACT CREATE, ${ctxArgs}`);
+        if (typeof model === "string") model = this.deserialize(model);
+        log.info(`Creating model: ${JSON.stringify(model)}`);
+        const transient = this.getTransientData(ctx);
+        log.info(`Merging transient data...`);
+        model = Model.merge(model, transient, this.clazz);
+        return this.repo.create(model, ...ctxArgs);
+    }
+    async read(ctx, key, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.read);
+        log.info(`reading entry with pk ${key} `);
+        return this.repo.read(key, ...ctxArgs);
+    }
+    getTransientData(ctx) {
+        const transientMap = ctx.stub.getTransient();
+        let transient = {};
+        if (transientMap.has(this.repo.tableName)) {
+            transient = JSON.parse(transientMap.get(this.repo.tableName)?.toString("utf8"));
+        }
+        return transient;
+    }
+    async update(ctx, model, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.update);
+        if (typeof model === "string") model = this.deserialize(model);
+        log.info(`Updating model: ${JSON.stringify(model)}`);
+        const transient = this.getTransientData(ctx);
+        log.info(`Merging transient data...`);
+        model = Model.merge(model, transient, this.clazz);
+        return this.repo.update(model, ...ctxArgs);
+    }
+    async delete(ctx, key, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.delete);
+        log.info(`deleting entry with pk ${key} `);
+        return this.repo.delete(String(key), ...ctxArgs);
+    }
+    async deleteAll(ctx, keys, ...args) {
+        const {ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.readAll);
+        if (typeof keys === "string") keys = JSON.parse(keys);
+        return this.repo.deleteAll(keys, ...ctxArgs);
+    }
+    async readAll(ctx, keys, ...args) {
+        const {ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.readAll);
+        if (typeof keys === "string") keys = JSON.parse(keys);
+        return this.repo.readAll(keys, ...ctxArgs);
+    }
+    async updateAll(ctx, models, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.updateAll);
+        if (typeof models === "string") models = JSON.parse(models).map(m => this.deserialize(m)).map(m => new this.clazz(m));
+        log.info(`updating ${models.length} entries to the table`);
+        return this.repo.updateAll(models, ...ctxArgs);
+    }
+    async query(context, condition, orderBy, order = OrderDirection.ASC, limit, skip, ...args) {
+        const {ctxArgs: ctxArgs} = await this.logCtx([ ...args, context ], this.query);
+        return this.repo.query(condition, orderBy, order, limit, skip, ...ctxArgs);
+    }
+    async raw(ctx, rawInput, docsOnly, ...args) {
+        const {ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.raw);
+        return FabricCrudContract.adapter.raw(rawInput, docsOnly, ...ctxArgs);
+    }
+    serialize(model) {
+        return FabricCrudContract.serializer.serialize(model);
+    }
+    deserialize(str) {
+        return FabricCrudContract.serializer.deserialize(str);
+    }
+    async init(ctx) {
+        const {log: log} = await this.logCtx([ ctx ], this.init);
+        log.info(`Running contract ${this.getName()} initialization...`);
+        this.initialized = true;
+        log.info(`Contract initialization completed.`);
+    }
+    async healthcheck(ctx) {
+        const {log: log} = await this.logCtx([ ctx ], this.healthcheck);
+        log.info(`Running Healthcheck: ${this.initialized}...`);
+        return {
+            healthcheck: this.initialized
+        };
+    }
+    async createAll(ctx, models, ...args) {
+        const {log: log, ctxArgs: ctxArgs} = await this.logCtx([ ...args, ctx ], this.createAll);
+        if (typeof models === "string") models = JSON.parse(models).map(m => this.deserialize(m)).map(m => new this.clazz(m));
+        log.info(`adding ${models.length} entries to the table`);
+        return this.repo.createAll(models, ...ctxArgs);
+    }
+    async logCtx(args, method) {
+        return FabricCrudContract.logCtx.bind(this)(args, method);
+    }
+    static async logCtx(args, method) {
+        if (args.length < 1) throw new InternalError("No context provided");
+        const ctx = args.pop();
+        if (ctx instanceof FabricContractContext) return {
+            ctx: ctx,
+            log: ctx.logger.clear().for(this).for(method),
+            ctxArgs: [ ...args, ctx ],
+            stub: ctx.stub,
+            identity: ctx.identity
+        };
+        if (!(ctx instanceof Context$1)) throw new InternalError("No valid context provided");
+        function getOp() {
+            if (typeof method === "string") return method;
+            switch (method.name) {
+              case OperationKeys.CREATE:
+              case OperationKeys.READ:
+              case OperationKeys.UPDATE:
+              case OperationKeys.DELETE:
+              case BulkCrudOperationKeys.CREATE_ALL:
+              case BulkCrudOperationKeys.READ_ALL:
+              case BulkCrudOperationKeys.UPDATE_ALL:
+              case BulkCrudOperationKeys.DELETE_ALL:
+                return method.name;
+
+              default:
+                return method.name;
+            }
+        }
+        const overrides = {
+            correlationId: ctx.stub.getTxID()
+        };
+        const context = await FabricCrudContract.adapter.context(getOp(), overrides, this.clazz, ctx);
+        const log = this ? context.logger.for(this).for(method) : context.logger.clear().for(this).for(method);
+        return {
+            ctx: context,
+            log: log,
+            stub: context.stub,
+            identity: context.identity,
+            ctxArgs: [ ...args, context ]
+        };
+    }
+}
+
+class SerializedCrudContract extends FabricCrudContract {
+    constructor(name, clazz) {
+        super(name, clazz);
+    }
+    async create(context, model) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.create);
+        log.info(`Creating model: ${model}`);
+        const m = this.deserialize(model);
+        log.info(`Model deserialized: ${JSON.stringify(m)}`);
+        const result = await super.create(ctx, m);
+        const serialized = this.serialize(result);
+        log.info(`RESULT: ${JSON.stringify(result)}`);
+        log.info(`Retuning: ${serialized}`);
+        return serialized;
+    }
+    async read(context, key) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.read);
+        log.info(`Reading id: ${key}`);
+        return this.serialize(await super.read(ctx, key));
+    }
+    async update(context, model) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.update);
+        log.info(`Updating model: ${model}`);
+        return this.serialize(await super.update(ctx, model));
+    }
+    async delete(context, key) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.delete);
+        log.info(`Deleting id: ${key}`);
+        return this.serialize(await super.delete(ctx, key));
+    }
+    async deleteAll(context, keys) {
+        const parsedKeys = JSON.parse(keys);
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.deleteAll);
+        log.info(`deleting ${parsedKeys.length} entries from the table`);
+        return JSON.stringify((await super.deleteAll(ctx, parsedKeys)).map(m => this.serialize(m)));
+    }
+    async readAll(context, keys) {
+        const parsedKeys = JSON.parse(keys);
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.readAll);
+        log.info(`reading ${parsedKeys.length} entries from the table`);
+        return JSON.stringify((await super.readAll(ctx, parsedKeys)).map(m => this.serialize(m)));
+    }
+    async updateAll(context, models) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.updateAll);
+        const list = JSON.parse(models);
+        const modelList = list.map(m => this.deserialize(m)).map(m => new this.clazz(m));
+        log.info(`Updating ${modelList.length} entries to the table`);
+        return JSON.stringify((await super.updateAll(ctx, modelList)).map(m => this.serialize(m)));
+    }
+    async statement(context, method, args) {
+        const {ctx: ctx, log: log} = await this.logCtx([ context ], this.statement);
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            throw new SerializationError(`Invalid args: ${e}`);
+        }
+        if (!Array.isArray(args)) throw new SerializationError(`Invalid args: ${JSON.stringify(args)}. must be an array`);
+        log.info(`calling prepared statement ${method}`);
+        log.info(`with args ${args}`);
+        return JSON.stringify(await super.statement(ctx, method, ...args));
+    }
+    async listBy(context, key, order) {
+        const {ctx: ctx, log: log} = await this.logCtx([ context ], this.listBy);
+        log.info(`Executing listBy with key ${key} and order ${order}`);
+        return JSON.stringify(await super.listBy(ctx, key, order));
+    }
+    async paginateBy(context, key, order, ref, ...args) {
+        const {ctx: ctx, log: log} = await this.logCtx([ ...args, context ], this.paginateBy);
+        try {
+            ref = JSON.parse(ref);
+        } catch (e) {
+            throw new SerializationError(`Failed to deserialize paginateBy reference: ${e}`);
+        }
+        log.info(`Executing paginateBy with key ${key} and order ${order}`);
+        return JSON.stringify(await super.paginateBy(ctx, key, order, ref, ...args));
+    }
+    async findOneBy(context, key, value, ...args) {
+        const {ctx: ctx, log: log} = await this.logCtx([ ...args, context ], this.findOneBy);
+        log.info(`Executing findOneBy with key ${key} and value ${value}`);
+        return JSON.stringify(await super.findOneBy(ctx, key, value, ...args));
+    }
+    async query(context, condition, orderBy, order, limit, skip) {
+        const {ctx: ctx, log: log} = await this.logCtx([ context ], this.query);
+        log.info(`Executing query orderedBy ${orderBy} and order ${order}`);
+        let cond;
+        try {
+            cond = Condition.from(JSON.parse(condition));
+        } catch (e) {
+            throw new SerializationError(`Invalid condition: ${e}`);
+        }
+        log.info(`Condition: ${JSON.stringify(cond)}`);
+        return JSON.stringify(await super.query(ctx, cond, orderBy, order, limit, skip));
+    }
+    async init(ctx) {
+        await super.init(ctx);
+    }
+    async healthcheck(context) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.updateAll);
+        log.debug(`Running Healthcheck: ${this.initialized}...`);
+        return JSON.stringify(await super.healthcheck(ctx));
+    }
+    async createAll(context, models) {
+        const {log: log} = await this.logCtx([ context ], this.createAll);
+        const list = JSON.parse(models);
+        const modelList = list.map(m => this.deserialize(m)).map(m => new this.clazz(m));
+        log.info(`Adding ${modelList.length} entries to the table`);
+        const result = await super.createAll(context, modelList);
+        return JSON.stringify(result.map(m => this.serialize(m)));
+    }
+}
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "create", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "read", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "update", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "delete", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "deleteAll", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "readAll", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "updateAll", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "statement", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "listBy", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String, String, FabricContractContext ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "paginateBy", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "findOneBy", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "init", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "healthcheck", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], SerializedCrudContract.prototype, "createAll", null);
+
+function add(a, b) {
+    const c = a + b;
+    if (a !== c - b || b !== c - a) {
+        throw new OverflowError(`Addition overflow: ${a} + ${b}`);
+    }
+    return c;
+}
+
+function sub(a, b) {
+    const c = a - b;
+    if (a !== c + b || b !== a - c) {
+        throw new OverflowError(`Subtraction overflow: ${a} - ${b}`);
+    }
+    return c;
+}
+
+function safeParseInt(string) {
+    const digitRegex = /^\d+$/;
+    if (!digitRegex.test(string)) {
+        throw new ValidationError(stringFormat("Failed to parse: {0}", "string contains digits"));
+    }
+    const parsedint = parseInt(string);
+    if (isNaN(parsedint)) {
+        throw new ValidationError(stringFormat("Failed to parse: {0}", "string is not a parsable integer"));
+    }
+    return parsedint;
+}
+
+let ERC20Token = class ERC20Token extends BaseModel {
+    constructor(m) {
+        super(m);
+    }
+};
+
+__decorate([ pk({
+    type: "String"
+}), __metadata("design:type", String) ], ERC20Token.prototype, "name", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", String) ], ERC20Token.prototype, "owner", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", String) ], ERC20Token.prototype, "symbol", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", Number) ], ERC20Token.prototype, "decimals", void 0);
+
+ERC20Token = __decorate([ table("erc20_tokens"), model(), __metadata("design:paramtypes", [ Object ]) ], ERC20Token);
+
+let ERC20Wallet = class ERC20Wallet extends BaseModel {
+    constructor(m) {
+        super(m);
+    }
+};
+
+__decorate([ pk({
+    type: "String"
+}), __metadata("design:type", String) ], ERC20Wallet.prototype, "id", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", String) ], ERC20Wallet.prototype, "token", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", Number) ], ERC20Wallet.prototype, "balance", void 0);
+
+__decorate([ column(), __metadata("design:type", String) ], ERC20Wallet.prototype, "captive", void 0);
+
+ERC20Wallet = __decorate([ table("erc20_wallets"), model(), __metadata("design:paramtypes", [ Object ]) ], ERC20Wallet);
+
+let Allowance = class Allowance extends BaseModel {
+    constructor(m) {
+        super(m);
+    }
+};
+
+__decorate([ pk({
+    type: "String"
+}), column(), required(), __metadata("design:type", String) ], Allowance.prototype, "owner", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", String) ], Allowance.prototype, "spender", void 0);
+
+__decorate([ column(), required(), __metadata("design:type", Number) ], Allowance.prototype, "value", void 0);
+
+Allowance = __decorate([ table("erc20_allowances"), model(), __metadata("design:paramtypes", [ Object ]) ], Allowance);
+
+function Owner() {
+    return function(target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function(...args) {
+            const ctx = args[0];
+            const acountId = ctx.clientIdentity.getID();
+            const select = await this["tokenRepository"].select();
+            const tokens = await select.execute(ctx);
+            if (tokens.length == 0) {
+                throw new NotFoundError("No tokens avaialble");
+            }
+            if (tokens.length > 1) {
+                throw new NotFoundError(`To many token available : ${tokens.length}`);
+            }
+            if (tokens[0].owner != acountId) {
+                throw new AuthorizationError(`User not authorized to run ${propertyKey} on the token`);
+            }
+            return await originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+
+async function ownedByOnCreate(context, data, key, model) {
+    const {stub: stub} = context;
+    const creator = await stub.getCreator();
+    const owner = creator.mspid;
+    const setOwnedByKeyValue = function(target, propertyKey, value) {
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            writable: false,
+            configurable: true,
+            value: value
+        });
+    };
+    setOwnedByKeyValue(model, key, owner);
+}
+
+function ownedBy() {
+    const key = getFabricModelKey(FabricModelKeys.OWNEDBY);
+    function ownedBy() {
+        return function(obj, attribute) {
+            return apply(required(), readonly(), onCreate(ownedByOnCreate), propMetadata(getFabricModelKey(FabricModelKeys.OWNEDBY), attribute))(obj, attribute);
+        };
+    }
+    return Decoration.for(key).define({
+        decorator: ownedBy,
+        args: []
+    }).apply();
+}
+
+async function transactionIdOnCreate(context, data, key, model) {
+    const {stub: stub} = context;
+    model[key] = stub.getTxID();
+}
+
+function transactionId() {
+    function transactionId() {
+        return function(obj, attribute) {
+            return apply(required(), readonly(), onCreate(transactionIdOnCreate), onUpdate(transactionIdOnCreate), propMetadata(Metadata.key(FabricModelKeys.FABRIC, attribute, FabricModelKeys.TRANSACTION_ID), attribute))(obj, attribute);
+        };
+    }
+    return Decoration.for(FabricModelKeys.TRANSACTION_ID).define({
+        decorator: transactionId,
+        args: []
+    }).apply();
+}
+
+function getFabricModelKey(key) {
+    return Metadata.key(FabricModelKeys.FABRIC + key);
+}
+
+const ImplicitPrivateCollection = model => `__${model.constructor.name}PrivateCollection`;
+
+async function segregatedDataOnCreate(context, data, keys, model) {
+    if (keys.length !== data.length) throw new InternalError(`Segregated data keys and metadata length mismatch`);
+    const collectionResolver = data[0].collections;
+    const collection = typeof collectionResolver === "string" ? collectionResolver : collectionResolver(model);
+    const rebuilt = keys.reduce((acc, k, i) => {
+        const c = typeof data[i].collections === "string" ? data[i].collections : data[i].collections(model);
+        if (c !== collection) throw new UnsupportedError(`Segregated data collection mismatch: ${c} vs ${collection}`);
+        acc[k] = model[k];
+        return acc;
+    }, {});
+    const toCreate = new this.class(rebuilt);
+    const created = await this.override({
+        segregated: collection
+    }).create(toCreate, context);
+    Object.assign(model, created);
+}
+
+async function segregatedDataOnRead(context, data, keys, model) {
+    if (keys.length !== data.length) throw new InternalError(`Segregated data keys and metadata length mismatch`);
+    const collectionResolver = data[0].collections;
+    const collection = typeof collectionResolver === "string" ? collectionResolver : collectionResolver(model);
+    const rebuilt = keys.reduce((acc, k, i) => {
+        const c = typeof data[i].collections === "string" ? data[i].collections : data[i].collections(model);
+        if (c !== collection) throw new UnsupportedError(`Segregated data collection mismatch: ${c} vs ${collection}`);
+        acc[k] = model[k];
+        return acc;
+    }, {});
+    const toCreate = new this.class(rebuilt);
+    const created = await this.override({
+        segregated: collection
+    }).create(toCreate, context);
+    Object.assign(model, created);
+}
+
+async function segregatedDataOnUpdate(context, data, key, model, oldModel) {}
+
+async function segregatedDataOnDelete(context, data, key, model) {}
+
+function segregated(collection, type) {
+    return function innerSegregated(target, propertyKey) {
+        function segregatedDec(target, propertyKey) {
+            if (!propertyKey) {
+                const props = Metadata.properties(target) || [];
+                for (const prop of props) segregated(collection, type)(target, prop);
+                return target;
+            }
+            const key = Metadata.key(type, propertyKey);
+            const constr = target.constructor;
+            const meta = Metadata.get(constr, key) || {};
+            const collections = new Set(meta.collections || []);
+            collections.add(collection);
+            meta.collections = [ ...collections ];
+            Metadata.set(constr, key, meta);
+        }
+        const decs = [];
+        if (!propertyKey) {
+            Metadata.properties(target)?.forEach(p => segregated(collection, type)(target, p));
+            return metadata(type, true)(target);
+        } else {
+            decs.push(transient(), segregatedDec, onCreate(segregatedDataOnCreate, {
+                collections: collection
+            }, {
+                priority: 95,
+                group: typeof collection === "string" ? collection : collection.toString()
+            }), onRead(segregatedDataOnRead, {
+                collections: collection
+            }, {
+                priority: 95,
+                group: typeof collection === "string" ? collection : collection.toString()
+            }), onUpdate(segregatedDataOnUpdate, {
+                collections: collection
+            }, {
+                priority: 95,
+                group: typeof collection === "string" ? collection : collection.toString()
+            }), onDelete(segregatedDataOnDelete, {
+                collections: collection
+            }, {
+                priority: 95,
+                group: typeof collection === "string" ? collection : collection.toString()
+            }));
+        }
+        return apply(...decs)(target, propertyKey);
+    };
+}
+
+function privateData(collection = ImplicitPrivateCollection) {
+    function privateData(collection) {
+        return segregated(collection, FabricModelKeys.PRIVATE);
+    }
+    return Decoration.for(FabricModelKeys.PRIVATE).define({
+        decorator: privateData,
+        args: [ collection ]
+    }).apply();
+}
+
+function sharedData(collection) {
+    function sharedData(collection) {
+        return segregated(collection, FabricModelKeys.SHARED);
+    }
+    return Decoration.for(FabricModelKeys.SHARED).define({
+        decorator: sharedData,
+        args: [ collection ]
+    }).apply();
+}
+
+var ERC20Events;
+
+(function(ERC20Events) {
+    ERC20Events["TRANSFER"] = "Transfer";
+    ERC20Events["APPROVAL"] = "Approval";
+})(ERC20Events || (ERC20Events = {}));
+
+class FabricERC20Contract extends FabricCrudContract {
+    constructor(name) {
+        super(name, ERC20Wallet);
+        FabricERC20Contract.adapter = FabricERC20Contract.adapter || new FabricContractAdapter;
+        this.walletRepository = FabricContractRepository.forModel(ERC20Wallet, FabricERC20Contract.adapter.alias);
+        this.tokenRepository = FabricContractRepository.forModel(ERC20Token, FabricERC20Contract.adapter.alias);
+        this.allowanceRepository = FabricContractRepository.forModel(Allowance, FabricERC20Contract.adapter.alias);
+    }
+    async TokenName(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const select = this.tokenRepository.select();
+        const token = (await select.execute(ctx))[0];
+        return token.name;
+    }
+    async Symbol(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const select = this.tokenRepository.select();
+        const token = (await select.execute(ctx))[0];
+        return token.symbol;
+    }
+    async Decimals(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const select = this.tokenRepository.select();
+        const token = (await select.execute(ctx))[0];
+        return token.decimals;
+    }
+    async TotalSupply(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const select = this.walletRepository.select();
+        const wallets = await select.execute(ctx);
+        if (wallets.length == 0) {
+            throw new NotFoundError(`The token ${this.getName()} does not exist`);
+        }
+        let total = 0;
+        wallets.forEach(wallet => {
+            total += wallet.balance;
+        });
+        return total;
+    }
+    async BalanceOf(context, owner) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const wallet = await this.walletRepository.read(owner, ctx);
+        return wallet.balance;
+    }
+    async Transfer(context, to, value) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.Transfer);
+        await this.CheckInitialized(ctx);
+        const from = ctx.identity.getID();
+        const transferResp = await this._transfer(from, to, value, ctx);
+        if (!transferResp) {
+            throw new InternalError("Failed to transfer");
+        }
+        return true;
+    }
+    async TransferFrom(context, from, to, value) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.BurnFrom);
+        await this.CheckInitialized(ctx);
+        const spender = ctx.identity.getID();
+        const allowance = await this._getAllowance(from, spender, ctx);
+        if (!allowance || allowance.value < 0) {
+            throw new AllowanceError(`spender ${spender} has no allowance from ${from}`);
+        }
+        const currentAllowance = allowance.value;
+        if (currentAllowance < value) {
+            throw new BalanceError("The spender does not have enough allowance to spend.");
+        }
+        const updatedAllowance = sub(currentAllowance, value);
+        const newAllowance = Object.assign({}, allowance, {
+            value: updatedAllowance
+        });
+        await this.allowanceRepository.update(newAllowance, ctx);
+        const transferResp = await this._transfer(from, to, value, ctx);
+        if (!transferResp) {
+            throw new InternalError("Failed to transfer");
+        }
+        return true;
+    }
+    async _transfer(from, to, value, ctx) {
+        const log = ctx.logger;
+        if (from === to) {
+            throw new AuthorizationError("cannot transfer to and from same client account");
+        }
+        if (value < 0) {
+            throw new BalanceError("transfer amount cannot be negative");
+        }
+        const fromWallet = await this.walletRepository.read(from, ctx);
+        const fromBalance = fromWallet.balance;
+        if (fromBalance < value) {
+            throw new BalanceError(`client account ${from} has insufficient funds.`);
+        }
+        let toWallet;
+        let newToWallet = false;
+        try {
+            toWallet = await this.walletRepository.read(to, ctx);
+        } catch (e) {
+            if (e instanceof BaseError) {
+                if (e.code === 404) {
+                    toWallet = new ERC20Wallet({
+                        id: to,
+                        balance: 0,
+                        token: await this.TokenName(ctx)
+                    });
+                    newToWallet = true;
+                } else {
+                    throw new InternalError(e.message);
+                }
+            } else {
+                throw new InternalError(e);
+            }
+        }
+        const toBalance = toWallet.balance;
+        const fromUpdatedBalance = sub(fromBalance, value);
+        const toUpdatedBalance = add(toBalance, value);
+        const updatedFromWallet = Object.assign({}, fromWallet, {
+            balance: fromUpdatedBalance
+        });
+        await this.walletRepository.update(updatedFromWallet, ctx);
+        const updatedToWallet = Object.assign({}, toWallet, {
+            balance: toUpdatedBalance
+        });
+        if (newToWallet) {
+            await this.walletRepository.create(updatedToWallet, ctx);
+        } else {
+            await this.walletRepository.update(updatedToWallet, ctx);
+        }
+        const transferEvent = {
+            from: from,
+            to: to,
+            value: value
+        };
+        this.repo.refresh(ERC20Token, ERC20Events.TRANSFER, "", transferEvent, ctx).catch(e => log.error(`Failed to notify transfer: ${e}`));
+        return true;
+    }
+    async Approve(context, spender, value) {
+        const {ctx: ctx, ctxArgs: ctxArgs} = await this.logCtx([ context ], this.Approve);
+        await this.CheckInitialized(ctx);
+        const owner = ctx.identity.getID();
+        let allowance = await this._getAllowance(owner, spender, ctx);
+        const ownerWallet = await this.walletRepository.read(owner, ...ctxArgs);
+        if (ownerWallet.balance < value) {
+            throw new BalanceError(`client account ${owner} has insufficient funds.`);
+        }
+        if (allowance) {
+            allowance.value = value;
+            await this.allowanceRepository.update(allowance, ...ctxArgs);
+        } else {
+            allowance = new Allowance({
+                owner: owner,
+                spender: spender,
+                value: value
+            });
+            await this.allowanceRepository.create(allowance, ...ctxArgs);
+        }
+        const approvalEvent = {
+            owner: owner,
+            spender: spender,
+            value: value
+        };
+        this.repo.refresh(ERC20Token, ERC20Events.APPROVAL, "", approvalEvent, ctx);
+        return true;
+    }
+    async Allowance(context, owner, spender) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.Allowance);
+        await this.CheckInitialized(ctx);
+        const allowance = await this._getAllowance(owner, spender, ctx);
+        if (!allowance) {
+            throw new AllowanceError(`spender ${spender} has no allowance from ${owner}`);
+        }
+        return allowance.value;
+    }
+    async _getAllowance(owner, spender, ctx) {
+        const allowanceCondition = Condition.and(Condition.attribute("owner").eq(owner), Condition.attribute("spender").eq(spender));
+        const allowance = await this.allowanceRepository.select().where(allowanceCondition).execute(ctx);
+        return allowance?.[0];
+    }
+    async Initialize(context, token) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.Initialize);
+        const tokens = await this.tokenRepository.select().execute(ctx);
+        if (tokens.length > 0) {
+            throw new AuthorizationError("contract options are already set, client is not authorized to change them");
+        }
+        token.owner = ctx.identity.getID();
+        await this.tokenRepository.create(token, ctx);
+        return true;
+    }
+    async CheckInitialized(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.CheckInitialized);
+        const tokens = await this.tokenRepository.select().execute(ctx);
+        if (tokens.length == 0) {
+            throw new NotInitializedError("contract options need to be set before calling any function, call Initialize() to initialize contract");
+        }
+    }
+    async Mint(context, amount) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.Mint);
+        await this.CheckInitialized(ctx);
+        const minter = ctx.identity.getID();
+        if (amount <= 0) {
+            throw new ValidationError("mint amount must be a positive integer");
+        }
+        let minterWallet;
+        try {
+            minterWallet = await this.walletRepository.read(minter, ctx);
+            const currentBalance = minterWallet.balance;
+            const updatedBalance = add(currentBalance, amount);
+            const updatedminter = Object.assign({}, minterWallet, {
+                balance: updatedBalance
+            });
+            await this.walletRepository.update(updatedminter, ctx);
+        } catch (e) {
+            if (e instanceof BaseError) {
+                if (e.code === 404) {
+                    const newWallet = new ERC20Wallet({
+                        id: minter,
+                        balance: amount,
+                        token: await this.TokenName(context)
+                    });
+                    await this.walletRepository.create(newWallet, ctx);
+                } else {
+                    throw new InternalError(e.message);
+                }
+            } else {
+                throw new InternalError(e);
+            }
+        }
+        const transferEvent = {
+            from: "0x0",
+            to: minter,
+            value: amount
+        };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(ERC20Token, ERC20Events.TRANSFER, "", transferEvent, ctx);
+    }
+    async Burn(context, amount) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.Burn);
+        await this.CheckInitialized(ctx);
+        const minter = ctx.identity.getID();
+        const minterWallet = await this.walletRepository.read(minter, ctx);
+        const currentBalance = minterWallet.balance;
+        if (currentBalance < amount) {
+            throw new BalanceError(`Minter has insufficient funds.`);
+        }
+        const updatedBalance = sub(currentBalance, amount);
+        const updatedminter = Object.assign({}, minterWallet, {
+            balance: updatedBalance
+        });
+        await this.walletRepository.update(updatedminter, ctx);
+        log.info(`${amount} tokens were burned`);
+        const transferEvent = {
+            from: minter,
+            to: "0x0",
+            value: amount
+        };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(ERC20Token, ERC20Events.TRANSFER, "", transferEvent, ctx);
+    }
+    async BurnFrom(context, account, amount) {
+        const {log: log, ctx: ctx} = await this.logCtx([ context ], this.BurnFrom);
+        await this.CheckInitialized(ctx);
+        const accountWallet = await this.walletRepository.read(account, ctx);
+        const currentBalance = accountWallet.balance;
+        if (currentBalance < amount) {
+            throw new BalanceError(`${account} has insufficient funds.`);
+        }
+        const updatedBalance = sub(currentBalance, amount);
+        const updatedaccount = Object.assign({}, accountWallet, {
+            balance: updatedBalance
+        });
+        await this.walletRepository.update(updatedaccount, ctx);
+        log.info(`${amount} tokens were burned from ${account}`);
+        const transferEvent = {
+            from: account,
+            to: "0x0",
+            value: amount
+        };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(ERC20Token, ERC20Events.TRANSFER, "", transferEvent, ctx);
+    }
+    async ClientAccountBalance(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.TokenName);
+        await this.CheckInitialized(ctx);
+        const clientAccountID = ctx.identity.getID();
+        const clientWallet = await this.walletRepository.read(clientAccountID, ctx);
+        if (!clientWallet) {
+            throw new BalanceError(`The account ${clientAccountID} does not exist`);
+        }
+        return clientWallet.balance;
+    }
+    async ClientAccountID(context) {
+        const {ctx: ctx} = await this.logCtx([ context ], this.ClientAccountID);
+        await this.CheckInitialized(ctx);
+        const clientAccountID = ctx.identity.getID();
+        return clientAccountID;
+    }
+}
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "TokenName", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Symbol", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Decimals", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "TotalSupply", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "BalanceOf", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Transfer", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "TransferFrom", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Approve", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, String ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Allowance", null);
+
+__decorate([ Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, ERC20Token ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Initialize", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "CheckInitialized", null);
+
+__decorate([ Owner(), Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Mint", null);
+
+__decorate([ Owner(), Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "Burn", null);
+
+__decorate([ Owner(), Transaction(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1, String, Number ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "BurnFrom", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "ClientAccountBalance", null);
+
+__decorate([ Transaction(false), __metadata("design:type", Function), __metadata("design:paramtypes", [ Context$1 ]), __metadata("design:returntype", Promise) ], FabricERC20Contract.prototype, "ClientAccountID", null);
+
+const contracts = [ FabricERC20Contract ];
+
+const VERSION = "0.1.48";
+
+const PACKAGE_NAME = "@decaf-ts/for-fabric";
+
+Metadata.registerLibrary(PACKAGE_NAME, VERSION);
+
+export { ContractLogger, FabricContractAdapter, FabricContractContext, FabricContractPaginator, FabricContractRepository, FabricContractRepositoryObservableHandler, FabricCrudContract, FabricStatement, PACKAGE_NAME, SerializedCrudContract, VERSION, contracts, createdByOnFabricCreateUpdate, pkFabricOnCreate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-fabric.js","sources":["../src/contracts/ContractContext.ts","../src/shared/events.ts","../src/contracts/FabricContractRepositoryObservableHandler.ts","../src/contracts/FabricContractRepository.ts","../src/contracts/FabricContractStatement.ts","../src/contracts/FabricContractSequence.ts","../src/shared/constants.ts","../src/shared/SimpleDeterministicSerializer.ts","../src/contracts/logging.ts","../src/contracts/FabricContractPaginator.ts","../src/shared/errors.ts","../src/contracts/ContractAdapter.ts","../src/shared/DeterministicSerializer.ts","../src/contracts/crud/crud-contract.ts","../src/contracts/crud/serialized-crud-contract.ts","../src/shared/math.ts","../src/contracts/erc20/models.ts","../src/shared/decorators.ts","../src/shared/erc20/erc20-constants.ts","../src/contracts/erc20/erc20contract.ts","../src/contracts/erc20/index.ts","../src/version.ts"],"sourcesContent":["import { Context } from \"@decaf-ts/core\";\nimport { FabricContractFlags } from \"./types\";\nimport { ChaincodeStub, ClientIdentity } from \"fabric-shim-api\";\n\n/**\n * @description Context class for Fabric chaincode operations\n * @summary Provides access to Fabric-specific context elements like stub, identity, and logger to be used by repositories and adapters during contract execution.\n * @template F - Flags specific to Fabric contract operations\n * @param {object} [args] - Optional initialization arguments passed to the base Context\n * @return {void}\n * @class FabricContractContext\n * @example\n * ```typescript\n * // In a Fabric chaincode contract method\n * const context = new FabricContractContext();\n * // Optionally set values via the base Context API\n * context.set('stub', ctx.stub);\n * context.set('clientIdentity', ctx.clientIdentity);\n * context.set('logger', contractLogger);\n *\n * // Access context properties\n * const timestamp = context.timestamp;\n * const creator = context.identity.getID();\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Contract\n *   participant Context\n *   participant Ledger\n *   Contract->>Context: new FabricContractContext()\n *   Contract->>Context: set('stub'|'clientIdentity'|'logger', ...)\n *   Context-->>Contract: timestamp, identity, logger\n *   Contract->>Ledger: Interact via stub\n */\nexport class FabricContractContext extends Context<FabricContractFlags> {\n  /**\n   * @description Creates a new FabricContractContext instance\n   * @summary Initializes the context with Fabric-specific flags\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * @description Gets the chaincode stub\n   * @summary Returns the ChaincodeStub instance for interacting with the ledger\n   * @return {ChaincodeStub} The chaincode stub\n   */\n  get stub(): ChaincodeStub {\n    return this.get(\"stub\");\n  }\n\n  /**\n   * @description Gets the transaction timestamp\n   * @summary Overrides the base timestamp getter to use the stub's timestamp\n   * @return {Date} The transaction timestamp\n   */\n  override get timestamp(): Date {\n    return this.stub.getDateTimestamp();\n  }\n\n  /**\n   * @description Gets the client identity\n   * @summary Returns the ClientIdentity instance for the transaction submitter\n   * @return {ClientIdentity} The client identity\n   */\n  get identity(): ClientIdentity {\n    return this.get(\"identity\");\n  }\n\n  override toString() {\n    return `fabric ctx${this.stub ? \" with stub\" : \"without stub\"}`;\n  }\n}\n","import { BulkCrudOperationKeys, OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Generates a Fabric event name from components\n * @summary Creates a standardized event name by joining table, event, and optional owner with underscores\n * @param {string} table - The table/collection name\n * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n * @param {string} [owner] - Optional owner identifier\n * @return {string} The generated event name in format \"table_event\" or \"table_event_owner\"\n * @function generateFabricEventName\n * @memberOf module:for-fabric.shared\n */\nexport function generateFabricEventName(\n  table: string,\n  event: OperationKeys | BulkCrudOperationKeys | string,\n  owner?: string\n) {\n  const params = [table, event];\n  if (owner) params.push(owner);\n  return params.join(\"_\");\n}\n\n/**\n * @description Parses a Fabric event name into its components\n * @summary Splits an event name by underscores and extracts table, event, and optional owner\n * @param {string} name - The event name to parse\n * @return {{table: string, event: OperationKeys | BulkCrudOperationKeys | string, owner: string}} The parsed components as a structured object\n * @throws {InternalError} If the event name format is invalid\n * @function parseEventName\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant Parser as parseEventName\n *   Caller->>Parser: parseEventName(name)\n *   Parser->>Parser: split name by \"_\"\n *   alt parts length invalid\n *     Parser-->>Caller: throw InternalError\n *   else\n *     Parser-->>Caller: { table, event, owner? }\n *   end\n * @memberOf module:for-fabric.shared\n */\nexport function parseEventName(name: string): {\n  table?: string;\n  event: OperationKeys | BulkCrudOperationKeys | string;\n  owner?: string;\n} {\n  const parts = name.split(\"_\");\n  if (parts.length < 2 || parts.length > 3)\n    return { table: undefined, event: name, owner: undefined };\n  return {\n    table: parts[0],\n    event: parts[1],\n    owner: parts[2],\n  } as {\n    table: string;\n    event: OperationKeys | BulkCrudOperationKeys | string;\n    owner?: string;\n  };\n}\n","import { BulkCrudOperationKeys, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport {\n  Adapter,\n  ContextualArgs,\n  EventIds,\n  ObserverHandler,\n} from \"@decaf-ts/core\";\nimport { generateFabricEventName } from \"../shared/events\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { Constructor } from \"@decaf-ts/decoration\";\n\n/**\n * @description Observer handler for Fabric chaincode events\n * @summary Emits events on the Fabric ledger when repository operations occur\n * @class FabricContractRepositoryObservableHandler\n * @extends {ObserverHandler}\n * @example\n * ```typescript\n * // In a Fabric chaincode contract\n * import { FabricContractRepositoryObservableHandler } from '@decaf-ts/for-fabric';\n *\n * // Create a handler with default supported events\n * const handler = new FabricContractRepositoryObservableHandler();\n *\n * // Emit an event\n * await handler.updateObservers(\n *   logger,\n *   'assets',\n *   OperationKeys.CREATE,\n *   'asset1',\n *   context\n * );\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Repository\n *   participant ObservableHandler\n *   participant Stub\n *   participant Ledger\n *\n *   Repository->>ObservableHandler: updateObservers(log, table, event, id, ctx)\n *   ObservableHandler->>ObservableHandler: Check if event is supported\n *   ObservableHandler->>ObservableHandler: generateFabricEventName(table, event, owner)\n *   ObservableHandler->>Stub: setEvent(eventName, payload)\n *   Stub->>Ledger: Record event\n */\nexport class FabricContractRepositoryObservableHandler extends ObserverHandler {\n  /**\n   * @description Creates a new FabricContractRepositoryObservableHandler instance\n   * @summary Initializes the handler with a list of supported events\n   * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [supportedEvents] - Events that will trigger Fabric events\n   */\n  constructor(\n    private supportedEvents: (\n      | OperationKeys\n      | BulkCrudOperationKeys\n      | string\n    )[] = [\n      OperationKeys.CREATE,\n      OperationKeys.UPDATE,\n      OperationKeys.DELETE,\n      BulkCrudOperationKeys.CREATE_ALL,\n      BulkCrudOperationKeys.UPDATE_ALL,\n      BulkCrudOperationKeys.DELETE_ALL,\n    ]\n  ) {\n    super();\n  }\n\n  /**\n   * @description Updates observers by emitting Fabric events\n   * @summary Emits events on the Fabric ledger for supported event types\n   * @param {Logger} log - Logger instance for debugging\n   * @param {string} table - The table/collection name\n   * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n   * @param {EventIds} id - The event identifier\n   * @param {FabricContractContext} ctx - The Fabric contract context\n   * @param {string} [owner] - Optional owner identifier for the event\n   * @param {object | string | undefined} [owner] - Optional payload for the event\n   *\n   * @return {Promise<void>} Promise that resolves when the event is emitted\n   */\n  override async updateObservers(\n    clazz: string | Constructor<any>,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<FabricContractContext>\n  ): Promise<void> {\n    const { log, ctx } = Adapter.logCtx<FabricContractContext>(\n      args,\n      this.updateObservers\n    );\n    const { stub } = ctx;\n    const [owner, payload] = args;\n    const table = typeof clazz === \"string\" ? clazz : clazz.name;\n    if (this.supportedEvents.indexOf(event) !== -1) {\n      log.debug(`Emitting ${event} event`);\n      const eventName = generateFabricEventName(table, event, owner);\n      stub.setEvent(eventName, Buffer.from(JSON.stringify({ id: id })));\n    } else {\n      stub.setEvent(event, Buffer.from(JSON.stringify(payload)));\n    }\n  }\n}\n","import {\n  Repository,\n  ObserverHandler,\n  EventIds,\n  ContextualArgs,\n  MaybeContextualArg,\n  QueryError,\n  Context,\n  PersistenceKeys,\n  PreparedStatementKeys,\n  OrderDirection,\n  SerializedPage,\n  Paginator,\n  DirectionLimitOffset,\n} from \"@decaf-ts/core\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { FabricContractRepositoryObservableHandler } from \"./FabricContractRepositoryObservableHandler\";\nimport {\n  BaseError,\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricContractAdapter } from \"./ContractAdapter\";\n\n/**\n * @description Repository for Hyperledger Fabric chaincode models\n * @summary Provides CRUD operations for models within Fabric chaincode contracts\n * @template M - Type extending Model\n * @template MangoQuery - Query type for CouchDB-like queries\n * @template FabricContractAdapter - Adapter type for Fabric contract operations\n * @template FabricContractFlags - Flags specific to Fabric contract operations\n * @template FabricContractContext - Context type for Fabric contract operations\n *\n * @param {FabricContractAdapter} [adapter] - The adapter for interacting with the state database\n * @param {Constructor<M>} [clazz] - The model constructor\n * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [trackedEvents] - Events to track for observer notifications\n *\n * @class FabricContractRepository\n * @example\n * ```typescript\n * // In a Fabric chaincode contract class\n * import { FabricContractRepository, FabricContractAdapter } from '@decaf-ts/for-fabric';\n *\n * @table('assets')\n * class Asset extends Model {\n *   @id()\n *   id: string;\n *\n *   @property()\n *   data: string;\n * }\n *\n * export class MyContract extends Contract {\n *   private adapter = new FabricContractAdapter();\n *   private repository: FabricContractRepository<Asset>;\n *\n *   constructor() {\n *     super('MyContract');\n *     this.repository = new FabricContractRepository<Asset>(this.adapter, Asset);\n *   }\n *\n *   @Transaction()\n *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {\n *     const asset = new Asset();\n *     asset.id = id;\n *     asset.data = data;\n *\n *     await this.repository.create(asset, { stub: ctx.stub });\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Contract\n *   participant Repository\n *   participant Adapter\n *   participant StateDB\n *\n *   Contract->>Repository: create(model, ctx)\n *   Repository->>Adapter: prepare(model, pk)\n *   Repository->>Adapter: create(tableName, id, record, transient, ctx)\n *   Adapter->>StateDB: putState(id, serializedData)\n *   StateDB-->>Adapter: Success\n *   Adapter-->>Repository: record\n *   Repository->>Adapter: revert(record, class, pk, id, transient)\n *   Adapter-->>Repository: model\n *   Repository-->>Contract: model\n */\nexport class FabricContractRepository<M extends Model> extends Repository<\n  M,\n  FabricContractAdapter\n> {\n  protected override _overrides = Object.assign({}, super[\"_overrides\"], {\n    ignoreValidation: false,\n    ignoreHandlers: false,\n    allowRawStatements: true,\n    forcePrepareSimpleQueries: false,\n    forcePrepareComplexQueries: false,\n  });\n\n  constructor(\n    adapter?: FabricContractAdapter,\n    clazz?: Constructor<M>,\n    protected trackedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[]\n  ) {\n    super(adapter, clazz);\n  }\n\n  override async paginateBy(\n    key: keyof M,\n    order: OrderDirection,\n    ref: Omit<DirectionLimitOffset, \"direction\"> = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<FabricContractContext>\n  ): Promise<SerializedPage<M>> {\n    // eslint-disable-next-line prefer-const\n    let { offset, bookmark, limit } = ref;\n    if (!offset && !bookmark)\n      throw new QueryError(`PaginateBy needs a page or a bookmark`);\n    const contextArgs = await Context.args(\n      PreparedStatementKeys.PAGE_BY,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const { log, ctxArgs } = this.logCtx(contextArgs.args, this.paginateBy);\n    log.verbose(\n      `paginating ${Model.tableName(this.class)} with page size ${limit}`\n    );\n\n    let paginator: Paginator<M>;\n    if (bookmark) {\n      paginator = await this.override({\n        forcePrepareComplexQueries: false,\n        forcePrepareSimpleQueries: false,\n      } as any)\n        .select()\n        .where(this.attr(Model.pk(this.class)).gt(bookmark))\n        .orderBy([key, order])\n        .paginate(limit as number, ...ctxArgs);\n      offset = 1;\n    } else if (offset) {\n      paginator = await this.override({\n        forcePrepareComplexQueries: false,\n        forcePrepareSimpleQueries: false,\n      } as any)\n        .select()\n        .orderBy([key, order])\n        .paginate(limit as number, ...ctxArgs);\n    } else {\n      throw new QueryError(`PaginateBy needs a page or a bookmark`);\n    }\n    const paged = await paginator.page(offset, ...ctxArgs);\n    return paginator.serialize(paged) as SerializedPage<M>;\n  }\n\n  override async statement(\n    name: string,\n    ...args: MaybeContextualArg<FabricContractContext>\n  ) {\n    if (!Repository.statements(this, name as keyof typeof this))\n      throw new QueryError(`Invalid prepared statement requested ${name}`);\n    const contextArgs = await Context.args(\n      PersistenceKeys.STATEMENT,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (contextArgs.context.logger) {\n      contextArgs.context.logger.info(`Repo statement: ${name} + ${args}`);\n    }\n    const { log, ctxArgs } = this.logCtx(contextArgs.args, this.statement);\n    log.verbose(`Executing prepared statement ${name} with args ${ctxArgs}`);\n\n    let result: any;\n    try {\n      result = await (this as any)[name](...ctxArgs);\n    } catch (e: unknown) {\n      if (e instanceof BaseError) throw e;\n      throw new InternalError(\n        `Failed to execute prepared statement ${name} with args ${ctxArgs}: ${e}`\n      );\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Gets the observer handler for this repository\n   * @summary Returns a FabricContractRepositoryObservableHandler instance\n   * @return {ObserverHandler} The observer handler\n   */\n  override ObserverHandler(): ObserverHandler {\n    return new FabricContractRepositoryObservableHandler();\n  }\n\n  /**\n   * @description Updates observers based on tracked events\n   * @summary Filters events based on trackedEvents and delegates to the parent method\n   * @param {string} table - The table/collection name\n   * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n   * @param {EventIds} id - The event identifier\n   * @param {FabricContractContext} ctx - The Fabric contract context\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<void>} Promise that resolves when observers are updated\n   */\n  override async updateObservers(\n    table: Constructor<M> | string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<FabricContractContext>\n  ): Promise<void> {\n    if (!this.trackedEvents || this.trackedEvents.indexOf(event) !== -1)\n      return await super.updateObservers(table, event, id, ...args);\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  CouchDBAdapter,\n  CouchDBGroupOperator,\n  CouchDBKeys,\n  CouchDBOperator,\n  MangoOperator,\n  MangoQuery,\n  MangoSelector,\n} from \"@decaf-ts/for-couchdb\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { CouchDBStatement } from \"@decaf-ts/for-couchdb\";\nimport { Condition, OrderDirection } from \"@decaf-ts/core\";\nimport { Metadata } from \"@decaf-ts/decoration\";\nimport { DBKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Statement wrapper for executing Mango queries within Fabric contracts\n * @summary Bridges CouchDB-style queries to Fabric via the FabricContractAdapter, handling identity and primary key projection when needed.\n * @template M - Model type this statement operates on\n * @template R - Result type returned by the statement\n * @param {FabricContractAdapter} adapter - The Fabric contract adapter used for raw execution\n * @param {FabricContractContext} ctx - The Fabric contract context carrying stub and identity\n * @return {void}\n * @class FabricStatement\n * @example\n * const stmt = new FabricStatement<MyModel, MyModel[]>(adapter, ctx);\n * const result = await stmt.raw<MyModel[]>({ selector: { type: 'MyModel' } });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Statement\n *   participant Adapter\n *   participant Ledger\n *   App->>Statement: raw({ selector })\n *   Statement->>Adapter: adapter.raw(mango, true, ctx)\n *   Adapter->>Ledger: Evaluate query\n *   Adapter-->>Statement: rows\n *   Statement-->>App: models\n */\nexport class FabricStatement<M extends Model, R> extends CouchDBStatement<\n  M,\n  CouchDBAdapter<any, void, FabricContractContext>,\n  R\n> {\n  constructor(adapter: CouchDBAdapter<any, void, FabricContractContext>) {\n    super(adapter);\n  }\n\n  override async raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R> {\n    const { ctx } = this.logCtx(args, this.raw);\n\n    const results: any[] = await this.adapter.raw(rawInput, true, ctx);\n\n    const pkAttr = Model.pk(this.fromSelector);\n    const type = Metadata.get(\n      this.fromSelector,\n      Metadata.key(DBKeys.ID, pkAttr as string)\n    )?.type;\n\n    if (!this.selectSelector)\n      return results.map((r) => this.processRecord(r, pkAttr, type, ctx)) as R;\n    return results as R;\n  }\n\n  override build(): MangoQuery {\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Model.tableName(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            console.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelector) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      const [selector, value] = this.orderBySelector as [\n        string,\n        OrderDirection,\n      ];\n      const rec: any = {};\n      rec[selector] = value;\n      (query.sort as any[]).push(rec as any);\n      if (!query.selector[selector]) {\n        query.selector[selector] = {} as MangoSelector;\n        (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n          null;\n      }\n    }\n\n    if (this.limitSelector) query.limit = this.limitSelector;\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n}\n","import {\n  ConflictError,\n  InternalError,\n  NotFoundError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Adapter,\n  Context,\n  MaybeContextualArg,\n  Sequence,\n  SequenceModel,\n  SequenceOptions,\n  Serial,\n  UnsupportedError,\n  UUID,\n} from \"@decaf-ts/core\";\nimport { style } from \"@decaf-ts/logging\";\n\n/**\n * @description Abstract base class for sequence generation\n * @summary Provides a framework for generating sequential values (like primary keys) in the persistence layer.\n * Implementations of this class handle the specifics of how sequences are stored and incremented in different\n * database systems.\n * @param {SequenceOptions} options - Configuration options for the sequence generator\n * @class Sequence\n * @example\n * ```typescript\n * // Example implementation for a specific database\n * class PostgresSequence extends Sequence {\n *   constructor(options: SequenceOptions) {\n *     super(options);\n *   }\n *\n *   async next(): Promise<number> {\n *     // Implementation to get next value from PostgreSQL sequence\n *     const result = await this.options.executor.raw(`SELECT nextval('${this.options.name}')`);\n *     return parseInt(result.rows[0].nextval);\n *   }\n *\n *   async current(): Promise<number> {\n *     // Implementation to get current value from PostgreSQL sequence\n *     const result = await this.options.executor.raw(`SELECT currval('${this.options.name}')`);\n *     return parseInt(result.rows[0].currval);\n *   }\n *\n *   async range(count: number): Promise<number[]> {\n *     // Implementation to get a range of values\n *     const values: number[] = [];\n *     for (let i = 0; i < count; i++) {\n *       values.push(await this.next());\n *     }\n *     return values;\n *   }\n * }\n *\n * // Usage\n * const sequence = new PostgresSequence({\n *   name: 'user_id_seq',\n *   executor: dbExecutor\n * });\n *\n * const nextId = await sequence.next();\n * ```\n */\nexport class FabricContractSequence extends Sequence {\n  /**\n   * @description Creates a new sequence instance\n   * @summary Protected constructor that initializes the sequence with the provided options\n   */\n  constructor(options: SequenceOptions, adapter: Adapter<any, any, any>) {\n    super(options, adapter);\n  }\n\n  /**\n   * @description Retrieves the current value of the sequence\n   * @summary Gets the current value of the sequence from storage. If the sequence\n   * doesn't exist yet, it returns the configured starting value.\n   * @return A promise that resolves to the current sequence value\n   */\n  override async current(\n    ...args: MaybeContextualArg<any>\n  ): Promise<string | number | bigint> {\n    const contextArgs = await Context.args<any, any>(\n      OperationKeys.READ,\n      SequenceModel,\n      args,\n      this.adapter\n    );\n    const ctx = contextArgs.context;\n    const { name, startWith } = this.options;\n    try {\n      const sequence: SequenceModel = await this.repo.read(name as string, ctx);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      const log = ctx.logger.for(this.current);\n      if (e instanceof NotFoundError) {\n        let cachedCurrent: any;\n        try {\n          log.debug(\n            `Trying to resolve current sequence ${name} value from context`\n          );\n          cachedCurrent = ctx.get(name);\n          log.debug(\n            `Retrieved cached current value for sequence ${name}: ${cachedCurrent}`\n          );\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (e: unknown) {\n          log.info(`No cached value for sequence ${name} in context`);\n          cachedCurrent = startWith;\n        }\n        try {\n          return this.parse(cachedCurrent);\n        } catch (e: any) {\n          throw new InternalError(\n            `Failed to parse initial value for sequence ${startWith}: ${e}`\n          );\n        }\n      }\n      throw new InternalError(\n        `Failed to retrieve current value for sequence ${name}: ${e}`\n      );\n    }\n  }\n\n  /**\n   * @description Increments the sequence value\n   * @summary Increases the current sequence value by the specified amount and persists\n   * the new value to storage. This method handles both numeric and BigInt sequence types.\n   * @param {string | number | bigint} current - The current value of the sequence\n   * @param {number} [count] - Optional amount to increment by, defaults to the sequence's incrementBy value\n   * @return A promise that resolves to the new sequence value after incrementing\n   */\n  protected override async increment(\n    count: number | undefined,\n    ctx: Context<any>\n  ): Promise<string | number | bigint> {\n    const log = ctx.logger.for(this.increment);\n    const { type, incrementBy, name } = this.options;\n    if (!name) throw new InternalError(\"Sequence name is required\");\n    log.info(`Obtaining sequence lock for sequence ${name}`);\n    return FabricContractSequence.lock.execute(async () => {\n      const toIncrementBy = count || incrementBy;\n      if (toIncrementBy % incrementBy !== 0)\n        throw new InternalError(\n          `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n        );\n      const typeName =\n        typeof type === \"function\" && (type as any)?.name\n          ? (type as any).name\n          : type;\n      const currentValue = await this.current(ctx);\n\n      async function returnAndCache(\n        res: SequenceModel | Promise<SequenceModel>\n      ) {\n        if (res instanceof Promise) res = await res;\n        ctx.logger\n          .for(returnAndCache)\n          .info(`Storing new ${name} seq value in cache: ${res.current}`);\n        ctx.cache.put(name as string, res.current);\n        return res;\n      }\n\n      const performUpsert = async (\n        next: string | number | bigint\n      ): Promise<SequenceModel> => {\n        try {\n          return await returnAndCache(\n            this.repo.update(\n              new SequenceModel({ id: name, current: next }),\n              ctx\n            )\n          );\n        } catch (e: any) {\n          if (e instanceof NotFoundError) {\n            log.debug(\n              `Sequence create ${name} current=${currentValue as any} next=${next as any}`\n            );\n            return returnAndCache(\n              this.repo.create(\n                new SequenceModel({ id: name, current: next }),\n                ctx\n              )\n            );\n          }\n          throw e;\n        }\n      };\n\n      const incrementSerial = (\n        base: string | number | bigint\n      ): string | number | bigint => {\n        switch (typeName) {\n          case Number.name:\n            return (this.parse(base) as number) + toIncrementBy;\n          case BigInt.name:\n            return (this.parse(base) as bigint) + BigInt(toIncrementBy);\n          case String.name:\n            return this.parse(base);\n          case \"serial\":\n            return Serial.instance.generate(base as string);\n          default:\n            throw new InternalError(\"Should never happen\");\n        }\n      };\n\n      if (typeName === \"uuid\") {\n        while (true) {\n          const next = UUID.instance.generate(currentValue as string);\n          try {\n            const result = await performUpsert(next);\n            log.debug(\n              `Sequence uuid increment ${name} current=${currentValue as any} next=${next as any}`\n            );\n            return result.current as string | number | bigint;\n          } catch (e: unknown) {\n            if (e instanceof ConflictError) continue;\n            throw e;\n          }\n        }\n      }\n\n      const next = incrementSerial(currentValue);\n      const seq = await performUpsert(next);\n      log.debug(\n        `Sequence.increment ${name} current=${currentValue as any} next=${next as any}`\n      );\n      return seq.current as string | number | bigint;\n    }, name);\n  }\n}\n","/**\n * @description Keys used to mark Fabric-specific model metadata\n * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum FabricModelKeys {\n  /** Private data marker used to tag properties or models for Fabric private collections */\n  PRIVATE = \"private\",\n  SHARED = \"shared\",\n  /** Namespace prefix used for Fabric-specific metadata keys */\n  FABRIC = \"fabric.\",\n  OWNEDBY = \"owned-by\",\n  TRANSACTION_ID = \"transaction-id\",\n}\n/**\n * @description Supported identity types for Fabric credentials\n * @summary Enumeration of identity formats recognized by this library\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum IdentityType {\n  /** Standard X.509 identity format used by Hyperledger Fabric */\n  X509 = \"X.509\",\n}\n\n/**\n * @description String identifier for the Fabric adapter flavour\n * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric\n * @const FabricFlavour\n * @memberOf module:for-fabric.shared\n */\nexport const FabricFlavour = \"hlf-fabric\";\n","import {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\n\nexport class SimpleDeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  override deserialize(str: string, tableName?: string): M {\n    const deserialization = JSON.parse(str);\n    // const className = tableName;\n    // if (!className)\n    //   throw new Error(\"Could not find class reference in serialized model\");\n\n    // // this will return undefined values\n    // const model: M = Model.build(deserialization, className) as unknown as M;\n\n    // // Populate Model\n    // const processedDesealization = Object.keys(model).reduce(\n    //   (accum: M, key) => {\n    //     (accum as Record<string, any>)[key] =\n    //       deserialization[Repository.column(accum, key)];\n    //     return accum;\n    //   },\n    //   model\n    // );\n\n    // const result = Model.build(\n    //   processedDesealization,\n    //   className\n    // ) as unknown as M;\n\n    // return result;\n    return deserialization;\n  }\n\n  override serialize(model: M, putAnchor = true): string {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const stringify = require(\"json-stringify-deterministic\");\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const sortKeysRecursive = require(\"sort-keys-recursive\");\n    const preSerialization = this.preSerialize(model, putAnchor);\n    return stringify(sortKeysRecursive(preSerialization));\n  }\n\n  protected override preSerialize(model: M, putAnchor: boolean = true) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    if (putAnchor)\n      toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    function preSerialize(\n      this: SimpleDeterministicSerializer<any>,\n      obj: any\n    ): any {\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map(preSerialize);\n      return this.preSerialize(obj);\n    }\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize.call(this, toSerialize[r]);\n    });\n    return toSerialize;\n  }\n}\n","import {\n  LoggerFactory,\n  Logging,\n  Logger,\n  LogLevel,\n  MiniLogger,\n  NumericLogLevels,\n  StringLike,\n} from \"@decaf-ts/logging\";\nimport { LoggingConfig } from \"@decaf-ts/logging\";\nimport { Context as Ctx } from \"fabric-contract-api\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Logger implementation for Fabric chaincode contracts\n * @summary Adapts the standard logging interface to work with Fabric's chaincode context\n *\n * @param {string} context - The logging context name\n * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration\n * @param {Ctx} ctx - The Fabric chaincode context\n *\n * @class ContractLogger\n * @extends {MiniLogger}\n * @example\n * ```typescript\n * // In a Fabric chaincode contract\n * import { ContractLogger } from '@decaf-ts/for-fabric';\n *\n * export class MyContract extends Contract {\n *   @Transaction()\n *   async myFunction(ctx: Context): Promise<void> {\n *     const logger = new ContractLogger('MyContract', { level: 'info' }, ctx);\n *\n *     logger.info('Processing transaction');\n *     logger.debug('Transaction details:', { ... });\n *\n *     // Do something\n *\n *     logger.info('Transaction complete');\n *   }\n * }\n * ```\n */\nexport class ContractLogger extends MiniLogger {\n  /**\n   * @description The underlying Fabric logger instance\n   */\n  protected logger!: Logger;\n\n  constructor(\n    context: string,\n    conf: Partial<LoggingConfig> | undefined,\n    ctx?: Ctx\n  ) {\n    super(context, conf);\n\n    if (!ctx) {\n      this.logger = new MiniLogger(context, conf);\n    } else {\n      this.logger = ctx.logging.getLogger(context) as unknown as Logger;\n    }\n  }\n\n  /**\n   * @description Logs a message at the specified level\n   * @summary Overrides the base log method to use the Fabric context's logger\n   * @param {LogLevel} level - The log level\n   * @param {StringLike | Error} msg - The message to log\n   * @param {Error} [stack] - Optional stack trace for errors\n   * @return {void}\n   */\n  protected override log(\n    level: LogLevel,\n    msg: StringLike | Error,\n    stack?: Error\n  ) {\n    if (\n      NumericLogLevels[this.config(\"level\") as LogLevel] <\n      NumericLogLevels[level]\n    )\n      return;\n\n    let method;\n    switch (level) {\n      case LogLevel.info:\n        method = this.logger.info;\n        break;\n      case LogLevel.verbose:\n        method = this.logger.verbose;\n        break;\n      case LogLevel.debug:\n        method = this.logger.debug;\n        break;\n      case LogLevel.error:\n        method = this.logger.error;\n        break;\n      case LogLevel.warn:\n        method = this.logger.warn;\n        break;\n      case LogLevel.silly:\n        method = this.logger.silly;\n        break;\n      default:\n        throw new InternalError(\"Invalid log level\");\n    }\n    method.call(this.logger, this.createLog(level, msg, stack));\n  }\n}\n\n/**\n * @description Factory function for creating ContractLogger instances\n * @summary Creates a new ContractLogger with the given context, config, and Fabric context\n * @param {string} object - The logging context name\n * @param {Partial<LoggingConfig> | undefined} config - Optional logging configuration\n * @param {Ctx} ctx - The Fabric chaincode context\n * @return {ContractLogger} A new ContractLogger instance\n * @function factory\n * @memberOf module:fabric.contracts\n */\nconst factory: LoggerFactory = (\n  object?: string,\n  config?: Partial<LoggingConfig>,\n  ctx?: Ctx\n) => {\n  return new ContractLogger(\n    object || ContractLogger.name,\n    config || {},\n    ctx as Ctx\n  );\n};\n\n// Set the factory as the default logger factory\nLogging.setFactory(factory);\n","import {\n  MaybeContextualArg,\n  OrderDirection,\n  PagingError,\n  Sequence,\n} from \"@decaf-ts/core\";\nimport { DBKeys } from \"@decaf-ts/db-decorators\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { FabricContractAdapter } from \"./ContractAdapter\";\nimport { CouchDBPaginator, MangoQuery } from \"@decaf-ts/for-couchdb\";\n\n/**\n * @description Paginator for CouchDB query results\n * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets\n * @template M - The model type that extends Model\n * @template R - The result type\n * @param {FabricCo<any, any, any>} adapter - The CouchDB adapter\n * @param {MangoQuery} query - The Mango query to paginate\n * @param {number} size - The page size\n * @param {Constructor<M>} clazz - The model constructor\n * @class CouchDBPaginator\n * @example\n * // Example of using CouchDBPaginator\n * const adapter = new MyCouchDBAdapter(scope);\n * const query = { selector: { type: \"user\" } };\n * const paginator = new CouchDBPaginator(adapter, query, 10, User);\n *\n * // Get the first page\n * const page1 = await paginator.page(1);\n *\n * // Get the next page\n * const page2 = await paginator.page(2);\n */\nexport class FabricContractPaginator<\n  M extends Model,\n  R,\n> extends CouchDBPaginator<M, R> {\n  /**\n   * @description Creates a new CouchDBPaginator instance\n   * @summary Initializes a paginator for CouchDB query results\n   * @param {CouchDBAdapter<any, any, any, any>} adapter - The CouchDB adapter\n   * @param {MangoQuery} query - The Mango query to paginate\n   * @param {number} size - The page size\n   * @param {Constructor<M>} clazz - The model constructor\n   */\n  constructor(\n    adapter: FabricContractAdapter,\n    query: MangoQuery,\n    size: number,\n    clazz: Constructor<M>\n  ) {\n    super(adapter, query, size, clazz);\n  }\n\n  /**\n   * @description Prepares a query for pagination\n   * @summary Modifies the raw query to include pagination parameters\n   * @param {MangoQuery} rawStatement - The original Mango query\n   * @return {MangoQuery} The prepared query with pagination parameters\n   */\n  protected override prepare(rawStatement: MangoQuery): MangoQuery {\n    const query: MangoQuery = Object.assign({}, rawStatement);\n    if (query.limit) this.limit = query.limit;\n\n    query.limit = this.size;\n\n    return query;\n  }\n\n  /**\n   * @description Retrieves a specific page of results\n   * @summary Executes the query with pagination and processes the results\n   * @param {number} [page=1] - The page number to retrieve\n   * @return {Promise<R[]>} A promise that resolves to an array of results\n   * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant CouchDBPaginator\n   *   participant Adapter\n   *   participant CouchDB\n   *\n   *   Client->>CouchDBPaginator: page(pageNumber)\n   *   Note over CouchDBPaginator: Clone statement\n   *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)\n   *\n   *   alt page !== 1\n   *     CouchDBPaginator->>CouchDBPaginator: Check bookmark\n   *     alt No bookmark\n   *       CouchDBPaginator-->>Client: Throw PagingError\n   *     else Has bookmark\n   *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement\n   *     end\n   *   end\n   *\n   *   CouchDBPaginator->>Adapter: raw(statement, false)\n   *   Adapter->>CouchDB: Execute query\n   *   CouchDB-->>Adapter: Return results\n   *   Adapter-->>CouchDBPaginator: Return MangoResponse\n   *\n   *   Note over CouchDBPaginator: Process results\n   *\n   *   alt Has warning\n   *     CouchDBPaginator->>CouchDBPaginator: Log warning\n   *   end\n   *\n   *   CouchDBPaginator->>CouchDBPaginator: Check for clazz\n   *\n   *   alt No clazz\n   *     CouchDBPaginator-->>Client: Throw PagingError\n   *   else Has clazz\n   *     CouchDBPaginator->>CouchDBPaginator: Find primary key\n   *\n   *     alt Has fields in statement\n   *       CouchDBPaginator->>CouchDBPaginator: Use docs directly\n   *     else No fields\n   *       CouchDBPaginator->>CouchDBPaginator: Process each document\n   *       loop For each document\n   *         CouchDBPaginator->>CouchDBPaginator: Extract original ID\n   *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)\n   *       end\n   *     end\n   *\n   *     CouchDBPaginator->>CouchDBPaginator: Store bookmark\n   *     CouchDBPaginator->>CouchDBPaginator: Update currentPage\n   *     CouchDBPaginator-->>Client: Return results\n   *   end\n   */\n  override async page(\n    page: number = 1,\n    ...args: MaybeContextualArg<any>\n  ): Promise<M[]> {\n    const { ctxArgs, ctx } = this.adapter[\"logCtx\"](args, this.page);\n    if (this.isPreparedStatement()) return this.pagePrepared(page, ...ctxArgs);\n    const statement = Object.assign({}, this.statement);\n\n    if (!this._recordCount || !this._totalPages) {\n      this._totalPages = this._recordCount = 0;\n      const results: R[] =\n        (await this.adapter.raw(\n          { ...statement, limit: undefined },\n          true,\n          ctx\n        )) || [];\n      this._recordCount = results.length;\n      if (this._recordCount > 0) {\n        const size = statement?.limit || this.size;\n        this._totalPages = Math.ceil(this._recordCount / size);\n      }\n    }\n\n    this.validatePage(page);\n\n    if (page !== 1) {\n      if (!this._bookmark)\n        throw new PagingError(\"No bookmark. Did you start in the first page?\");\n      statement[\"bookmark\"] = this._bookmark as string;\n    }\n    const docs: any[] = (await this.adapter.raw(statement, false, ctx)) as any;\n\n    if (!this.clazz) throw new PagingError(\"No statement target defined\");\n    const id = Model.pk(this.clazz);\n    const type = Metadata.get(\n      this.clazz,\n      Metadata.key(DBKeys.ID, id as string)\n    )?.type;\n    const results =\n      statement.fields && statement.fields.length\n        ? docs // has fields means its not full model\n        : docs.map((d: any) => {\n            return this.adapter.revert(\n              d,\n              this.clazz,\n              Sequence.parseValue(type, d[id]),\n              undefined,\n              ctx\n            );\n          });\n    const direction = statement.sort?.[0] || OrderDirection.DSC;\n    this._bookmark =\n      results[direction === OrderDirection.ASC ? results.length - 1 : 0][id];\n    this._currentPage = page;\n    return results;\n  }\n}\n","import { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\n// import { MISSING_PRIVATE_DATA_ERROR_MESSAGE } from \"../contracts/private-data\";\n/**\n * @summary Represents an overflow error in arithmetic operations in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class OverflowError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class OverflowError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, OverflowError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class BalanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, BalanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class AllowanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, AllowanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure registrating new entities\n *\n * @param {string} msg the error message\n *\n * @class RegistrationError\n *\n * @categort Errors\n */\nexport class RegistrationError extends AuthorizationError {\n  constructor(msg: string | Error) {\n    super(msg, RegistrationError.name);\n  }\n}\n\n/**\n * @description Error thrown when an unsupported operation is attempted\n * @summary This error is thrown when an operation is requested that is not supported by the current\n * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.\n * @param {string|Error} msg - The error message or an Error object to wrap\n * @class UnsupportedError\n * @example\n * ```typescript\n * // Throwing an UnsupportedError\n * if (!adapter.supportsTransactions()) {\n *   throw new UnsupportedError('Transactions are not supported by this adapter');\n * }\n *\n * // Catching an UnsupportedError\n * try {\n *   await adapter.beginTransaction();\n * } catch (error) {\n *   if (error instanceof UnsupportedError) {\n *     console.error('Operation not supported:', error.message);\n *   }\n * }\n * ```\n *\n * @category Errors\n */\nexport class MissingContextError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingContextError.name, 500);\n  }\n}\n\nexport class UnauthorizedPrivateDataAccess extends BaseError {\n  constructor(msg: string | Error = \"MISSING_PRIVATE_DATA_ERROR_MESSAGE\") {\n    super(UnauthorizedPrivateDataAccess.name, msg, 403);\n  }\n}\n\n/**\n * Represents an error that occurs when a required initialization step is not performed.\n *\n * @class NotInitializedError\n * @extends BaseError\n *\n * @category Errors\n *\n * @param {string | Error} msg - The error message or an Error object to wrap.\n *\n * @throws {NotInitializedError} - Throws an error when a required initialization step is not performed.\n *\n * @example\n * ```typescript\n * // Initialize the application\n * if (!isInitialized) {\n *   throw new NotInitializedError('Application is not initialized');\n * }\n *\n * // Catching an NotInitializedError\n * try {\n *   // Perform operations that require initialization\n * } catch (error) {\n *   if (error instanceof NotInitializedError) {\n *     console.error('Initialization error:', error.message);\n *   }\n * }\n * ```\n */\nexport class NotInitializedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(NotInitializedError.name, msg, 409);\n  }\n}\n\nexport class MissingPKCSS11Lib extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingPKCSS11Lib.name, 500);\n  }\n}\n\nexport class EndorsementError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementError.name, 500);\n  }\n}\n\nexport class MvccReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, MvccReadConflictError.name, 500);\n  }\n}\n\nexport class PhantomReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, PhantomReadConflictError.name, 500);\n  }\n}\n\nexport class EndorsementPolicyError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementPolicyError.name, 500);\n  }\n}\n","import { CouchDBAdapter, CouchDBKeys, MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { Model, ValidationKeys } from \"@decaf-ts/decorator-validation\";\nimport { FabricContractFlags } from \"./types\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport {\n  BadRequestError,\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n  onCreate,\n  onCreateUpdate,\n  OperationKeys,\n  PrimaryKeyType,\n  SerializationError,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Context as Ctx,\n  Object as FabricObject,\n  Property,\n  Property as FabricProperty,\n} from \"fabric-contract-api\";\nimport { Logger } from \"@decaf-ts/logging\";\nimport {\n  PersistenceKeys,\n  RelationsMetadata,\n  Sequence,\n  SequenceOptions,\n  UnsupportedError,\n  Adapter,\n  PreparedModel,\n  Repository,\n  QueryError,\n  PagingError,\n  MigrationError,\n  ObserverError,\n  AuthorizationError,\n  ForbiddenError,\n  ConnectionError,\n  ContextualizedArgs,\n  LoggerOf,\n  Context,\n  RawResult,\n  Paginator,\n  ContextualArgs,\n  MaybeContextualArg,\n} from \"@decaf-ts/core\";\nimport { FabricContractRepository } from \"./FabricContractRepository\";\nimport {\n  ChaincodeStub,\n  ClientIdentity,\n  Iterators,\n  StateQueryResponse,\n} from \"fabric-shim-api\";\nimport { FabricStatement } from \"./FabricContractStatement\";\nimport { FabricContractSequence } from \"./FabricContractSequence\";\nimport { FabricFlavour } from \"../shared/constants\";\nimport { SimpleDeterministicSerializer } from \"../shared/SimpleDeterministicSerializer\";\nimport {\n  Constructor,\n  Decoration,\n  Metadata,\n  propMetadata,\n} from \"@decaf-ts/decoration\";\nimport { ContractLogger } from \"./logging\";\nimport { FabricContractPaginator } from \"./FabricContractPaginator\";\nimport { MissingContextError } from \"../shared/errors\";\n\n/**\n * @description Sets the creator or updater field in a model based on the user in the context\n * @summary Callback function used in decorators to automatically set the created_by or updated_by fields\n * with the username from the context when a document is created or updated\n * @template M - Type extending Model\n * @template R - Type extending NanoRepository<M>\n * @template V - Type extending RelationsMetadata\n * @param {R} this - The repository instance\n * @param {FabricContractContext} context - The operation context containing user information\n * @param {V} data - The relation metadata\n * @param {string} key - The property key to set with the username\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function createdByOnFabricCreateUpdate\n * @memberOf module:fabric.contracts\n * @mermaid\n * sequenceDiagram\n *   participant F as createdByOnNanoCreateUpdate\n *   participant C as Context\n *   participant M as Model\n *   F->>C: get(\"user\")\n *   C-->>F: user object\n *   F->>M: set key to user.name\n *   Note over F: If no user in context\n *   F-->>F: throw UnsupportedError\n */\nexport async function createdByOnFabricCreateUpdate<\n  M extends Model,\n  R extends FabricContractRepository<M>,\n  V extends RelationsMetadata,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  try {\n    const user = context.get(\"identity\") as ClientIdentity;\n    model[key] = user.getID() as M[typeof key];\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    throw new UnsupportedError(\n      \"No User found in context. Please provide a user in the context\"\n    );\n  }\n}\n\n/**\n * @description Primary key auto-assignment callback for Fabric models\n * @summary Generates and assigns a primary key value to the specified model property using a Fabric-backed sequence when the model is created. If the sequence name is not provided in options, it is derived from the model via sequenceNameForModel. The assigned key is defined as non-writable and enumerable.\n * @template M - Type extending Model for the target instance\n * @template R - Type extending FabricContractRepository for repository context\n * @template V - Type extending SequenceOptions to configure sequence behavior\n * @template F - Type extending FabricContractFlags for contextual flags\n * @param {R} this - The repository instance invoking the callback\n * @param {FabricContractContext} context - Fabric contract context containing invocation metadata\n * @param {V} data - Sequence options used to configure or locate the sequence\n * @param {string} key - The primary key property name to assign on the model\n * @param {M} model - The model instance to receive the generated primary key\n * @return {Promise<void>} Resolves when the key is assigned or when no action is required\n * @function pkFabricOnCreate\n * @memberOf module:for-fabric.contracts\n * @mermaid\n * sequenceDiagram\n *   participant R as Repository\n *   participant C as Context<F>\n *   participant S as FabricContractDBSequence\n *   participant M as Model\n *   R->>R: derive sequence name if missing\n *   R->>S: adapter.Sequence(options)\n *   S-->>R: sequence instance\n *   R->>S: next(context)\n *   S-->>R: next value\n *   R->>M: define non-writable primary key\n */\nexport async function pkFabricOnCreate<\n  M extends Model,\n  R extends FabricContractRepository<M>,\n>(\n  this: R,\n  context: FabricContractContext,\n  data: SequenceOptions,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = Model.sequenceName(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = (await this.adapter.Sequence(data)) as Sequence;\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next(context as FabricContractContext);\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Adapter for Hyperledger Fabric chaincode state database operations\n * @summary Provides a CouchDB-like interface for interacting with the Fabric state database from within a chaincode contract\n * @template void - No configuration needed for contract adapter\n * @template FabricContractFlags - Flags specific to Fabric contract operations\n * @template FabricContractContext - Context type for Fabric contract operations\n * @class FabricContractAdapter\n * @example\n * ```typescript\n * // In a Fabric chaincode contract class\n * import { FabricContractAdapter } from '@decaf-ts/for-fabric';\n *\n * export class MyContract extends Contract {\n *   private adapter = new FabricContractAdapter();\n *\n *   @Transaction()\n *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {\n *     const model = { id, data, timestamp: Date.now() };\n *     await this.adapter.create('assets', id, model, {}, { stub: ctx.stub });\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Contract\n *   participant FabricContractAdapter\n *   participant Stub\n *   participant StateDB\n *\n *   Contract->>FabricContractAdapter: create(tableName, id, model, transient, ctx)\n *   FabricContractAdapter->>FabricContractAdapter: Serialize model to JSON\n *   FabricContractAdapter->>Stub: putState(id, serializedData)\n *   Stub->>StateDB: Write data\n *   StateDB-->>Stub: Success\n *   Stub-->>FabricContractAdapter: Success\n *   FabricContractAdapter-->>Contract: model\n */\nexport class FabricContractAdapter extends CouchDBAdapter<\n  any,\n  void,\n  FabricContractContext\n> {\n  protected override getClient(): void {\n    throw new UnsupportedError(\"Client is not supported in Fabric contracts\");\n  }\n  /**\n   * @description Text decoder for converting binary data to strings\n   */\n  private static textDecoder = new TextDecoder(\"utf8\");\n\n  protected static readonly serializer = new SimpleDeterministicSerializer();\n\n  /**\n   * @description Context constructor for this adapter\n   * @summary Overrides the base Context constructor with FabricContractContext\n   */\n  protected override readonly Context: Constructor<FabricContractContext> =\n    FabricContractContext;\n\n  /**\n   * @description Gets the repository constructor for this adapter\n   * @summary Returns the FabricContractRepository constructor for creating repositories\n   * @template M - Type extending Model\n   * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor\n   */\n  override repository<\n    R extends Repository<\n      any,\n      Adapter<any, void, MangoQuery, Context<FabricContractFlags>>\n    >,\n  >(): Constructor<R> {\n    return FabricContractRepository as unknown as Constructor<R>;\n  }\n\n  override Paginator<M extends Model>(\n    query: MangoQuery,\n    size: number,\n    clazz: Constructor<M>\n  ): Paginator<M, any, MangoQuery> {\n    return new FabricContractPaginator(this, query, size, clazz);\n  }\n\n  override async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new FabricContractSequence(options, this as any);\n  }\n\n  /**\n   * @description Creates a new FabricContractAdapter instance\n   * @summary Initializes an adapter for interacting with the Fabric state database\n   * @param {void} scope - Not used in this adapter\n   * @param {string} [alias] - Optional alias for the adapter instance\n   */\n  constructor(scope: void, alias?: string) {\n    super(scope, FabricFlavour, alias);\n  }\n\n  override for(config: Partial<any>, ...args: any): typeof this {\n    return super.for(config, ...args);\n  }\n\n  /**\n   * @description Creates a record in the state database\n   * @summary Serializes a model and stores it in the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The record data\n   * @param {Record<string, any>} transient - Transient data (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the created record\n   */\n  override async create<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricContractFlags>>\n  ): Promise<Record<string, any>> {\n    const { ctx, log } = this.logCtx(args, this.create);\n    log.info(`in ADAPTER create with args ${args}`);\n    const tableName = Model.tableName(clazz);\n    try {\n      log.info(`adding entry to ${tableName} table with pk ${id}`);\n      const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);\n      model = await this.putState(composedKey, model, ctx);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Reads a record from the state database\n   * @summary Retrieves and deserializes a record from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record\n   */\n  override async read<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricContractFlags>>\n  ): Promise<Record<string, any>> {\n    const { ctx, log } = this.logCtx(args, this.read);\n    log.info(`in ADAPTER read with args ${args}`);\n    const tableName = Model.tableName(clazz);\n\n    let model: Record<string, any>;\n    try {\n      const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);\n      model = await this.readState(composedKey, ctx);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Updates a record in the state database\n   * @summary Serializes a model and updates it in the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The updated record data\n   * @param {Record<string, any>} transient - Transient data (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the updated record\n   */\n  override async update<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricContractFlags>>\n  ): Promise<Record<string, any>> {\n    const { ctx, log } = this.logCtx(args, this.update);\n    const tableName = Model.tableName(clazz);\n\n    try {\n      log.verbose(`updating entry to ${tableName} table with pk ${id}`);\n      const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);\n      model = await this.putState(composedKey, model, ctx);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Deletes a record from the state database\n   * @summary Retrieves a record and then removes it from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier to delete\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the deleted record\n   */\n  async delete<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricContractFlags>>\n  ): Promise<Record<string, any>> {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.delete);\n    const tableName = Model.tableName(clazz);\n    let model: Record<string, any>;\n    try {\n      const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);\n      model = await this.read(clazz, id, ...ctxArgs);\n      log.verbose(`deleting entry with pk ${id} from ${tableName} table`);\n      await this.deleteState(composedKey, ctx);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  protected async deleteState(id: string, context: FabricContractContext) {\n    const { ctx } = this.logCtx([context], this.deleteState);\n    await ctx.stub.deleteState(id);\n  }\n\n  forPrivate(collection: string): FabricContractAdapter {\n    const toOverride = [\n      this.putState,\n      this.readState,\n      this.deleteState,\n      this.queryResult,\n      this.queryResultPaginated,\n    ].map((fn) => fn.name);\n    return new Proxy(this, {\n      get(target, prop, receiver) {\n        if (!toOverride.includes(prop as string))\n          return Reflect.get(target, prop, receiver);\n        return new Proxy((target as any)[prop], {\n          async apply(fn, thisArg, argsList) {\n            switch (prop) {\n              case \"putState\": {\n                const [stub, id, model] = argsList;\n                await stub.putPrivateData(collection, id.toString(), model);\n                return model;\n              }\n              case \"deleteState\": {\n                const [stub, id] = argsList;\n                return (stub as ChaincodeStub).deletePrivateData(\n                  collection,\n                  id\n                );\n              }\n              case \"readState\": {\n                const [stub, id] = argsList;\n                return stub.getPrivateData(collection, id);\n              }\n              case \"queryResult\": {\n                const [stub, rawInput] = argsList;\n                return stub.getPrivateDataQueryResult(collection, rawInput);\n              }\n              case \"queryResultPaginated\": {\n                const [stub, rawInput, limit, skip] = argsList;\n                const iterator = await (\n                  stub as ChaincodeStub\n                ).getPrivateDataQueryResult(collection, rawInput);\n                const results: any[] = [];\n                let count = 0;\n                let reachedBookmark = skip ? false : true;\n                let lastKey: string | null = null;\n\n                while (true) {\n                  const res = await iterator.next();\n\n                  if (res.value && res.value.value.toString()) {\n                    const recordKey = res.value.key;\n                    const recordValue = (res.value.value as any).toString(\n                      \"utf8\"\n                    );\n\n                    // If we have a skip, skip until we reach it\n                    if (!reachedBookmark) {\n                      if (recordKey === skip?.toString()) {\n                        reachedBookmark = true;\n                      }\n                      continue;\n                    }\n\n                    results.push({\n                      Key: recordKey,\n                      Record: JSON.parse(recordValue),\n                    });\n                    lastKey = recordKey;\n                    count++;\n\n                    if (count >= limit) {\n                      await iterator.close();\n                      return {\n                        iterator:\n                          results as unknown as Iterators.StateQueryIterator,\n                        metadata: {\n                          fetchedRecordsCount: results.length,\n                          bookmark: lastKey,\n                        },\n                      };\n                    }\n                  }\n\n                  if (res.done) {\n                    await iterator.close();\n                    return {\n                      iterator:\n                        results as unknown as Iterators.StateQueryIterator,\n                      metadata: {\n                        fetchedRecordsCount: results.length,\n                        bookmark: \"\",\n                      },\n                    };\n                  }\n                }\n              }\n              default:\n                throw new InternalError(\n                  `Unsupported method override ${String(prop)}`\n                );\n            }\n          },\n        });\n      },\n    });\n  }\n\n  protected async putState(\n    id: string,\n    model: Record<string, any>,\n    ctx: FabricContractContext\n  ) {\n    let data: Buffer;\n\n    const { log } = this.logCtx([ctx], this.putState);\n    try {\n      data = Buffer.from(\n        FabricContractAdapter.serializer.serialize(model as Model, false)\n      );\n    } catch (e: unknown) {\n      throw new SerializationError(\n        `Failed to serialize record with id ${id}: ${e}`\n      );\n    }\n\n    const collection = ctx.get(\"segregated\");\n    if (collection)\n      await ctx.stub.putPrivateData(collection, id.toString(), data);\n    else await ctx.stub.putState(id.toString(), data);\n\n    log.silly(\n      `state stored${collection ? ` in ${collection} collection` : \"\"} under id ${id}`\n    );\n    return model;\n  }\n\n  protected async readState(id: string, ctx: FabricContractContext) {\n    let result: any;\n\n    const { log } = this.logCtx([ctx], this.readState);\n    let res: string;\n    const collection = ctx.get(\"segregated\");\n    if (collection)\n      res = (\n        await ctx.stub.getPrivateData(collection, id.toString())\n      ).toString();\n    else res = (await ctx.stub.getState(id.toString())).toString();\n\n    if (!res)\n      throw new NotFoundError(\n        `Record with id ${id}${collection ? ` in ${collection} collection` : \"\"} not found`\n      );\n    log.silly(\n      `state retrieved from${collection ? ` ${collection} collection` : \"\"} under id ${id}`\n    );\n    try {\n      result = FabricContractAdapter.serializer.deserialize(res.toString());\n    } catch (e: unknown) {\n      throw new SerializationError(`Failed to parse record: ${e}`);\n    }\n\n    return result;\n  }\n\n  protected async queryResult(\n    stub: ChaincodeStub,\n    rawInput: any,\n    ...args: any[]\n  ): Promise<Iterators.StateQueryIterator> {\n    const { ctx } = this.logCtx(args, this.readState);\n    let res: Iterators.StateQueryIterator;\n    const collection = ctx.get(\"segregated\");\n    if (collection)\n      res = await ctx.stub.getPrivateDataQueryResult(\n        collection,\n        JSON.stringify(rawInput)\n      );\n    else res = await stub.getQueryResult(JSON.stringify(rawInput));\n\n    return res;\n  }\n\n  protected async queryResultPaginated(\n    stub: ChaincodeStub,\n    rawInput: any,\n    limit: number = 250,\n    skip?: number,\n    ...args: any[]\n  ): Promise<StateQueryResponse<Iterators.StateQueryIterator>> {\n    const { ctx } = this.logCtx(args, this.readState);\n    let res: StateQueryResponse<Iterators.StateQueryIterator>;\n    const collection = ctx.get(\"segregated\");\n    if (collection) {\n      rawInput.selector = {\n        ...rawInput.selector,\n        _id: skip ? { $gt: skip.toString() } : { $gte: \"\" },\n      };\n      const it = await stub.getPrivateDataQueryResult(\n        collection,\n        JSON.stringify(rawInput)\n      );\n      res = {\n        iterator: it,\n        metadata: {\n          fetchedRecordsCount: limit,\n          bookmark: \"\",\n        },\n      };\n    } else\n      res = await stub.getQueryResultWithPagination(\n        JSON.stringify(rawInput),\n        limit,\n        skip?.toString()\n      );\n\n    return res;\n  }\n\n  protected mergeModels(results: Record<string, any>[]): Record<string, any> {\n    const extract = (model: Record<string, any>) =>\n      Object.entries(model).reduce((accum: Record<string, any>, [key, val]) => {\n        if (typeof val !== \"undefined\") accum[key] = val;\n        return accum;\n      }, {});\n\n    let finalModel: Record<string, any> = results.pop() as Record<string, any>;\n\n    for (const res of results) {\n      finalModel = Object.assign({}, extract(finalModel), extract(res));\n    }\n\n    return finalModel;\n  }\n\n  /**\n   * @description Decodes binary data to string\n   * @summary Converts a Uint8Array to a string using UTF-8 encoding\n   * @param {Uint8Array} buffer - The binary data to decode\n   * @return {string} The decoded string\n   */\n  protected decode(buffer: Uint8Array) {\n    return FabricContractAdapter.textDecoder.decode(buffer);\n  }\n\n  /**\n   * @description Creates operation flags for Fabric contract operations\n   * @summary Merges default flags with Fabric-specific context information\n   * @template M - Type extending Model\n   * @param {OperationKeys} operation - The operation being performed\n   * @param {Constructor<M>} model - The model constructor\n   * @param {Partial<FabricContractFlags>} flags - Partial flags to merge with defaults\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @return {FabricContractFlags} The merged flags\n   */\n  protected override async flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<FabricContractFlags>,\n    ctx: Ctx | FabricContractContext,\n    ...args: any[]\n  ): Promise<FabricContractFlags> {\n    const baseFlags = {\n      stub: ctx.stub,\n      segregated: false,\n    };\n    if (ctx instanceof FabricContractContext) {\n      Object.assign(baseFlags, {\n        logger: ctx.logger,\n        identity: ctx.identity,\n        correlationId: ctx.stub.getTxID(),\n      });\n    } else {\n      Object.assign(baseFlags, {\n        identity: ctx.clientIdentity,\n        logger: new ContractLogger(this as any, undefined, ctx),\n        correlationId: ctx.stub.getTxID(),\n      });\n    }\n\n    flags = (await super.flags(\n      operation,\n      model,\n      baseFlags as any,\n      ...args\n    )) as FabricContractFlags;\n\n    return flags as FabricContractFlags;\n  }\n\n  /**\n   * @description Creates an index for a model\n   * @summary This method is not implemented for Fabric contracts and returns a resolved promise\n   * @template M - Type extending Model\n   * @param {Constructor<M>} models - The model constructor\n   * @return {Promise<void>} Promise that resolves immediately\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected index<M>(models: Constructor<M>): Promise<void> {\n    return Promise.resolve(undefined);\n  }\n\n  /**\n   * @description Processes results from a state query iterator\n   * @summary Iterates through query results and converts them to a structured format\n   * @param {Logger} log - Logger instance for debugging\n   * @param {Iterators.StateQueryIterator} iterator - The state query iterator\n   * @param {boolean} [isHistory=false] - Whether this is a history query\n   * @return {Promise<any[]>} Promise resolving to an array of processed results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant ResultIterator\n   *   participant Iterator\n   *\n   *   Caller->>ResultIterator: resultIterator(log, iterator, isHistory)\n   *   loop Until done\n   *     ResultIterator->>Iterator: next()\n   *     Iterator-->>ResultIterator: { value, done }\n   *     alt Has value\n   *       ResultIterator->>ResultIterator: Process value based on isHistory\n   *       ResultIterator->>ResultIterator: Add to results array\n   *     end\n   *   end\n   *   ResultIterator->>Iterator: close()\n   *   ResultIterator-->>Caller: allResults\n   */\n  protected async resultIterator(\n    log: Logger,\n    iterator: Iterators.StateQueryIterator,\n    isHistory = false\n  ) {\n    const allResults = [];\n    let res: { value: any; done: boolean } = await iterator.next();\n    while (!res.done) {\n      if (res.value && res.value.value.toString()) {\n        let jsonRes: any = {};\n        log.debug(res.value.value.toString(\"utf8\"));\n        if (isHistory /* && isHistory === true*/) {\n          jsonRes.TxId = res.value.txId;\n          jsonRes.Timestamp = res.value.timestamp;\n          try {\n            jsonRes.Value = JSON.parse(res.value.value.toString(\"utf8\"));\n          } catch (err: any) {\n            log.error(err);\n            jsonRes.Value = res.value.value.toString(\"utf8\");\n          }\n        } else {\n          try {\n            jsonRes = JSON.parse(res.value.value.toString(\"utf8\"));\n          } catch (err: any) {\n            log.error(err);\n            jsonRes = res.value.value.toString(\"utf8\");\n          }\n        }\n        allResults.push(jsonRes);\n      }\n      res = await iterator.next();\n    }\n    log.debug(`Closing iterator after ${allResults.length} results`);\n    iterator.close(); // purposely not await. let iterator close on its own\n    return allResults;\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Performs a rich query using CouchDB syntax against the Fabric state database\n   * @template R - The return type\n   * @param {MangoQuery} rawInput - The Mango Query to execute\n   * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<R>} Promise resolving to the query results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant FabricContractAdapter\n   *   participant Stub\n   *   participant StateDB\n   *\n   *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)\n   *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip\n   *   alt With pagination\n   *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)\n   *   else Without pagination\n   *     FabricContractAdapter->>Stub: getQueryResult(query)\n   *   end\n   *   Stub->>StateDB: Execute query\n   *   StateDB-->>Stub: Iterator\n   *   Stub-->>FabricContractAdapter: Iterator\n   *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)\n   *   FabricContractAdapter-->>Caller: results\n   */\n  async raw<R, D extends boolean>(\n    rawInput: MangoQuery,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    docsOnly: D = true as D,\n    ...args: ContextualArgs<FabricContractContext>\n  ): Promise<RawResult<R, D>> {\n    const { log, stub, ctx } = this.logCtx(args, this.raw);\n\n    const { skip, limit } = rawInput;\n    let iterator: Iterators.StateQueryIterator;\n    if (limit || skip) {\n      delete rawInput[\"limit\"];\n      delete rawInput[\"skip\"];\n      log.debug(\n        `Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`\n      );\n      const response: StateQueryResponse<Iterators.StateQueryIterator> =\n        (await this.queryResultPaginated(\n          stub,\n          rawInput,\n          limit || 250,\n          (skip as any)?.toString(),\n          ctx\n        )) as StateQueryResponse<Iterators.StateQueryIterator>;\n      iterator = response.iterator;\n    } else {\n      log.debug(\"Retrieving iterator\");\n      iterator = (await this.queryResult(\n        stub,\n        rawInput,\n        ctx\n      )) as Iterators.StateQueryIterator;\n    }\n    log.debug(\"Iterator acquired\");\n\n    const results = (await this.resultIterator(log, iterator)) as R;\n    log.debug(\n      `returning ${Array.isArray(results) ? results.length : 1} results`\n    );\n    return results as any;\n  }\n\n  override Statement<M extends Model>(): FabricStatement<M, any> {\n    return new FabricStatement(this as any);\n  }\n\n  override async createAll<M extends Model>(\n    tableName: Constructor<M>,\n    id: PrimaryKeyType[],\n    model: Record<string, any>[],\n    ...args: ContextualArgs<FabricContractContext>\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { log, ctxArgs } = this.logCtx(args, this.createAll);\n    const tableLabel = Model.tableName(tableName);\n    log.debug(`Creating ${id.length} entries ${tableLabel} table`);\n    return Promise.all(\n      id.map((i, count) => this.create(tableName, i, model[count], ...ctxArgs))\n    );\n  }\n\n  override async updateAll<M extends Model>(\n    tableName: Constructor<M>,\n    id: PrimaryKeyType[],\n    model: Record<string, any>[],\n    ...args: ContextualArgs<FabricContractContext>\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { log, ctxArgs } = this.logCtx(args, this.updateAll);\n    const tableLabel = Model.tableName(tableName);\n    log.debug(`Updating ${id.length} entries ${tableLabel} table`);\n    return Promise.all(\n      id.map((i, count) => this.update(tableName, i, model[count], ...ctxArgs))\n    );\n  }\n\n  /**\n   *\n   * @param model\n   * @param {string} pk\n   * @param args\n   */\n  override prepare<M extends Model>(\n    model: M,\n    ...args: ContextualArgs<FabricContractContext>\n  ): PreparedModel {\n    const { log } = this.logCtx(args, this.prepare);\n\n    const tableName = Model.tableName(model.constructor as any);\n    const pk = Model.pk(model.constructor as any);\n    const split = Model.segregate(model);\n    const result = Object.entries(split.model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        if (typeof val === \"undefined\") return accum;\n        const mappedProp = Model.columnName(model, key as any);\n        if (this.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n\n    log.silly(\n      `Preparing record for ${tableName} table with pk ${(model as any)[pk]}`\n    );\n\n    return {\n      record: result,\n      id: (model as any)[pk] as string,\n      transient: split.transient,\n    };\n  }\n\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    transient?: Record<string, any>,\n    ...args: ContextualArgs<FabricContractContext>\n  ): M {\n    const { log } = this.logCtx(args, this.revert);\n    const ob: Record<string, any> = {};\n    const pk = Model.pk(clazz);\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      (accum as Record<string, any>)[key] =\n        obj[Model.columnName(accum, key as any)];\n      return accum;\n    }, m);\n\n    if (transient) {\n      log.debug(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result && (result as any)[key] !== undefined)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    return result;\n  }\n\n  override createPrefix<M extends Model>(\n    tableName: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<FabricContractContext>\n  ) {\n    const { ctxArgs } = this.logCtx(args, this.createPrefix);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = Model.tableName(tableName);\n    Object.assign(record, model);\n\n    return [tableName, id, record, ...ctxArgs] as [\n      Constructor<M>,\n      PrimaryKeyType,\n      Record<string, any>,\n      ...any[],\n      FabricContractContext,\n    ];\n  }\n\n  override updatePrefix<M extends Model>(\n    tableName: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<FabricContractContext>\n  ): any[] {\n    const { ctxArgs } = this.logCtx(args, this.updatePrefix);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = Model.tableName(tableName);\n    Object.assign(record, model);\n\n    return [tableName, id, record, ...ctxArgs] as [\n      Constructor<M>,\n      PrimaryKeyType,\n      Record<string, any>,\n      ...any[],\n      FabricContractContext,\n    ];\n  }\n\n  protected override createAllPrefix<M extends Model>(\n    tableName: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: [...any, FabricContractContext]\n  ): (string | string[] | number[] | Record<string, any>[])[] {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const ctx: FabricContractContext = args.pop();\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = Model.tableName(tableName);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records, ctx as any];\n  }\n\n  protected override updateAllPrefix<M extends Model>(\n    tableName: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: [...any, FabricContractContext]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const ctx: FabricContractContext = args.pop();\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = Model.tableName(tableName);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records, ctx as any];\n  }\n\n  override parseError<E extends BaseError>(\n    err: Error | string,\n    reason?: string\n  ): E {\n    return FabricContractAdapter.parseError(reason || err);\n  }\n\n  override logCtx<ARGS extends any[]>(\n    args: ARGS,\n    method: ((...args: any[]) => any) | string\n  ): ContextualizedArgs<FabricContractContext, ARGS> & {\n    stub: ChaincodeStub;\n    identity: ClientIdentity;\n  } {\n    return FabricContractAdapter.logCtx.call(this, args, method as any) as any;\n  }\n\n  static override logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: string\n  ): ContextualizedArgs<FabricContractContext, ARGS> & {\n    stub: ChaincodeStub;\n    identity: ClientIdentity;\n  };\n  static override logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: (...args: any[]) => any\n  ): ContextualizedArgs<FabricContractContext, ARGS> & {\n    stub: ChaincodeStub;\n    identity: ClientIdentity;\n  };\n  static override logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: ((...args: any[]) => any) | string\n  ): ContextualizedArgs<FabricContractContext, ARGS> & {\n    stub: ChaincodeStub;\n    identity: ClientIdentity;\n  } {\n    if (args.length < 1) throw new InternalError(\"No context provided\");\n    const ctx = args.pop() as FabricContractContext;\n\n    if (!(ctx instanceof Context))\n      throw new InternalError(\"No context provided\");\n    if (args.filter((a) => a instanceof Context).length > 1)\n      throw new Error(\"here\");\n    const log = (\n      this\n        ? ctx.logger.for(this).for(method)\n        : ctx.logger.clear().for(this).for(method)\n    ) as LoggerOf<FabricContractContext>;\n    return {\n      ctx: ctx,\n      log: method ? (log.for(method) as LoggerOf<FabricContractContext>) : log,\n      stub: ctx.stub,\n      identity: ctx.identity,\n      ctxArgs: [...args, ctx],\n    };\n  }\n\n  static override parseError<E extends BaseError>(err: Error | string): E {\n    // if (\n    //   MISSING_PRIVATE_DATA_REGEX.test(\n    //     typeof err === \"string\" ? err : err.message\n    //   )\n    // )\n    //   return new UnauthorizedPrivateDataAccess(err) as E;\n    const msg = typeof err === \"string\" ? err : err.message;\n    if (msg.includes(NotFoundError.name)) return new NotFoundError(err) as E;\n    if (msg.includes(ConflictError.name)) return new ConflictError(err) as E;\n    if (msg.includes(BadRequestError.name))\n      return new BadRequestError(err) as E;\n    if (msg.includes(QueryError.name)) return new QueryError(err) as E;\n    if (msg.includes(PagingError.name)) return new PagingError(err) as E;\n    if (msg.includes(UnsupportedError.name))\n      return new UnsupportedError(err) as E;\n    if (msg.includes(MigrationError.name)) return new MigrationError(err) as E;\n    if (msg.includes(ObserverError.name)) return new ObserverError(err) as E;\n    if (msg.includes(AuthorizationError.name))\n      return new AuthorizationError(err) as E;\n    if (msg.includes(ForbiddenError.name)) return new ForbiddenError(err) as E;\n    if (msg.includes(ConnectionError.name))\n      return new ConnectionError(err) as E;\n    if (msg.includes(SerializationError.name))\n      return new SerializationError(err) as E;\n    if (msg.includes(\"no ledger context\"))\n      return new MissingContextError(\n        `No context found. this can be caused by debugging: ${msg}`\n      ) as E;\n\n    return new InternalError(err) as E;\n  }\n\n  /**\n   * @description Static method for decoration overrides\n   * @summary Overrides/extends decaf decoration with Fabric-specific functionality\n   * @static\n   * @override\n   * @return {void}\n   */\n  static override decoration(): void {\n    super.decoration();\n    Decoration.flavouredAs(FabricFlavour)\n      .for(PersistenceKeys.CREATED_BY)\n      .define(\n        onCreate(createdByOnFabricCreateUpdate),\n        propMetadata(PersistenceKeys.CREATED_BY, {})\n      )\n      .apply();\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(PersistenceKeys.UPDATED_BY)\n      .define(\n        onCreateUpdate(createdByOnFabricCreateUpdate),\n        propMetadata(PersistenceKeys.UPDATED_BY, {})\n      )\n      .apply();\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(PersistenceKeys.COLUMN)\n      .extend(FabricProperty())\n      .apply();\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(ValidationKeys.DATE)\n      .extend(function fabricProperty() {\n        return (target: any, prop?: any) => {\n          Property(prop, \"string:date\")(target, prop);\n        };\n      });\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(PersistenceKeys.TABLE)\n      .extend(function table(obj: any) {\n        const chain: any[] = [];\n        let current =\n          typeof obj === \"function\"\n            ? Metadata.constr(obj)\n            : Metadata.constr(obj.constructor);\n\n        while (current && current !== Object && current.prototype) {\n          chain.push(current);\n          current = Object.getPrototypeOf(current);\n        }\n\n        console.log(chain.map((c) => c.name || c));\n\n        // Apply from the base class down to the decorated class\n        while (chain.length > 0) {\n          const constructor = chain.pop();\n          console.log(`Calling on ${constructor.name}`);\n          FabricObject()(constructor);\n        }\n\n        return FabricObject()(obj);\n      })\n      .apply();\n  }\n}\n\nFabricContractAdapter.decoration();\nAdapter.setCurrent(FabricFlavour);\n","/* eslint-disable @typescript-eslint/no-require-imports */\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Deterministic JSON serializer for Fabric models\n * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.\n * @template M - The Decaf Model subtype serialized by this instance\n * @param {void} [constructor] No public constructor arguments\n * @class DeterministicSerializer\n * @example\n * const serializer = new DeterministicSerializer<MyModel>();\n * const json = serializer.serialize(model);\n * const rebuilt = serializer.deserialize(json);\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant DS as DeterministicSerializer\n *   Caller->>DS: serialize(model)\n *   DS->>DS: preSerialize(model)\n *   DS->>DS: sort-keys-recursive\n *   DS->>DS: json-stringify-deterministic\n *   DS-->>Caller: string\n *   Caller->>DS: deserialize(string)\n *   DS-->>Caller: model\n */\nexport class DeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n  protected override preSerialize(model: M) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    const preSerialize = function preSerialize(\n      this: DeterministicSerializer<any>,\n      obj: any\n    ): any {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this;\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map((o) => preSerialize.call(self, o));\n      return this.preSerialize.call(this, obj);\n    }.bind(this);\n\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize(toSerialize[r]);\n    });\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  override deserialize(str: string): M {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: M = Model.build(deserialization, className) as unknown as M;\n    return model;\n  }\n\n  /**\n   * @description Serialize a model into a deterministic JSON string\n   * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering\n   * @param {M} model - The model instance to serialize\n   * @return {string} Deterministic JSON representation of the model\n   */\n  override serialize(model: M): string {\n    const stringify = require(\"json-stringify-deterministic\");\n    const sortKeysRecursive = require(\"sort-keys-recursive\");\n    return stringify(sortKeysRecursive(this.preSerialize(model)));\n  }\n}\n","import { FabricContractAdapter } from \"../ContractAdapter\";\nimport { Contract, Context as Ctx } from \"fabric-contract-api\";\nimport { Model, Serializer } from \"@decaf-ts/decorator-validation\";\nimport {\n  Condition,\n  Context,\n  ContextualizedArgs,\n  DirectionLimitOffset,\n  LoggerOf,\n  MaybeContextualArg,\n  OrderDirection,\n  Repository,\n  SerializedPage,\n} from \"@decaf-ts/core\";\nimport { FabricContractRepository } from \"../FabricContractRepository\";\nimport { DeterministicSerializer } from \"../../shared/DeterministicSerializer\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { Checkable, healthcheck } from \"../../shared/interfaces/Checkable\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricContractContext } from \"../ContractContext\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n  PrimaryKeyType,\n} from \"@decaf-ts/db-decorators\";\nimport { ChaincodeStub, ClientIdentity } from \"fabric-shim-api\";\nimport { Object as FabricObject } from \"fabric-contract-api\";\n\nFabricObject()(Date);\n/**\n * @description Base contract class for CRUD operations in Fabric chaincode\n * @summary Provides standard create, read, update, and delete operations for models in Fabric chaincode\n * @template M - Type extending Model\n * @class FabricCrudContract\n * @extends {Contract}\n * @example\n * ```typescript\n * // Define a model\n * @table('assets')\n * class Asset extends Model {\n *   @id()\n *   id: string;\n *\n *   @property()\n *   data: string;\n * }\n *\n * // Create a contract that extends FabricCrudContract\n * export class AssetContract extends FabricCrudContract<Asset> {\n *   constructor() {\n *     super('AssetContract', Asset);\n *   }\n *\n *   // Add custom methods as needed\n *   async getAssetHistory(ctx: Context, id: string): Promise<any[]> {\n *     // Custom implementation\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Contract\n *   participant Repository\n *   participant Adapter\n *   participant StateDB\n *\n *   Client->>Contract: create(ctx, model)\n *   Contract->>Repository: repository(ctx)\n *   Contract->>Repository: create(model, ctx)\n *   Repository->>Adapter: create(tableName, id, record, transient, ctx)\n *   Adapter->>StateDB: putState(id, serializedData)\n *   StateDB-->>Adapter: Success\n *   Adapter-->>Repository: record\n *   Repository-->>Contract: model\n *   Contract-->>Client: model\n */\nexport abstract class FabricCrudContract<M extends Model>\n  extends Contract\n  implements Checkable\n{\n  /**\n   * @description Shared adapter instance for all contract instances\n   */\n  protected static adapter: FabricContractAdapter = new FabricContractAdapter();\n\n  protected readonly repo: FabricContractRepository<M>;\n\n  protected static readonly serializer = new DeterministicSerializer();\n\n  protected initialized: boolean = false;\n\n  /**\n   * @description Creates a new FabricCrudContract instance\n   * @summary Initializes a contract with a name and model class\n   * @param {string} name - The name of the contract\n   * @param {Constructor<M>} clazz - The model constructor\n   */\n  protected constructor(\n    name: string,\n    protected readonly clazz: Constructor<M>\n  ) {\n    super(name);\n    this.repo = Repository.forModel(clazz);\n  }\n\n  async listBy(\n    ctx: Ctx | FabricContractContext,\n    key: string | keyof M,\n    order: string,\n    ...args: any[]\n  ): Promise<M[] | string> {\n    const { ctxArgs, log } = await this.logCtx([...args, ctx], this.listBy);\n    log.info(\n      `Running listBy key ${key as string}, order ${order} and args ${ctxArgs}`\n    );\n    return this.repo.listBy(\n      key as keyof M,\n      order as OrderDirection,\n      ...ctxArgs\n    );\n  }\n\n  async paginateBy(\n    ctx: Ctx | FabricContractContext,\n    key: string | keyof M,\n    order: string,\n    ref: Omit<DirectionLimitOffset, \"direction\"> | string = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<FabricContractContext>\n  ): Promise<SerializedPage<M> | string> {\n    const { ctxArgs, log } = await this.logCtx([...args, ctx], this.paginateBy);\n    log.info(\n      `Running paginateBy key ${key as string}, order ${order} with size ${(ref as any).limit} and args ${ctxArgs}`\n    );\n    return this.repo.paginateBy(\n      key as keyof M,\n      order as any,\n      ref as any,\n      ...ctxArgs\n    );\n  }\n\n  async findOneBy(\n    ctx: Ctx | FabricContractContext,\n    key: string | keyof M,\n    value: any,\n    ...args: any[]\n  ): Promise<M | string> {\n    const { ctxArgs, log } = await this.logCtx([...args, ctx], this.findOneBy);\n    log.info(\n      `Running findOneBy key ${key as string}, value: ${value} with args ${ctxArgs}`\n    );\n    return this.repo.findOneBy(key as keyof M, value, ...ctxArgs);\n  }\n\n  async statement(\n    ctx: Ctx | FabricContractContext,\n    method: string,\n    ...args: any[]\n  ): Promise<any> {\n    const { ctxArgs, log } = await this.logCtx([...args, ctx], this.statement);\n    log.info(`Running statement ${method} with args ${ctxArgs}`);\n    return this.repo.statement(method, ...ctxArgs);\n  }\n\n  /**\n   * @description Creates a single model in the state database\n   * @summary Delegates to the repository's create method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M} model - The model to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the created model\n   */\n  async create(\n    ctx: Ctx | FabricContractContext,\n    model: string | M,\n    ...args: any[]\n  ): Promise<string | M> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.create);\n    log.info(`CONTRACT CREATE, ${ctxArgs}`);\n\n    if (typeof model === \"string\") model = this.deserialize<M>(model) as M;\n\n    log.info(`Creating model: ${JSON.stringify(model)}`);\n\n    const transient = this.getTransientData(ctx);\n\n    log.info(`Merging transient data...`);\n    model = Model.merge(model, transient, this.clazz) as M;\n\n    return this.repo.create(model, ...ctxArgs);\n  }\n\n  /**\n   * @description Reads a single model from the state database\n   * @summary Delegates to the repository's read method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string | number} key - The key of the model to read\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the retrieved model\n   */\n  async read(\n    ctx: Ctx | FabricContractContext,\n    key: PrimaryKeyType | string,\n    ...args: any[]\n  ): Promise<M | string> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.read);\n\n    log.info(`reading entry with pk ${key} `);\n\n    return this.repo.read(key, ...ctxArgs);\n  }\n\n  protected getTransientData(ctx: Ctx | FabricContractContext): any {\n    const transientMap = ctx.stub.getTransient();\n    let transient: any = {};\n\n    if (transientMap.has((this.repo as any).tableName)) {\n      transient = JSON.parse(\n        (transientMap.get((this.repo as any).tableName) as Buffer)?.toString(\n          \"utf8\"\n        ) as string\n      );\n    }\n\n    return transient;\n  }\n\n  /**\n   * @description Updates a single model in the state database\n   * @summary Delegates to the repository's update method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M} model - The model to update\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the updated model\n   */\n  async update(\n    ctx: Ctx | FabricContractContext,\n    model: string | M,\n    ...args: any[]\n  ): Promise<string | M> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.update);\n\n    if (typeof model === \"string\") model = this.deserialize<M>(model) as M;\n\n    log.info(`Updating model: ${JSON.stringify(model)}`);\n\n    const transient = this.getTransientData(ctx);\n\n    log.info(`Merging transient data...`);\n    model = Model.merge(model, transient, this.clazz) as M;\n    return this.repo.update(model, ...ctxArgs);\n  }\n\n  /**\n   * @description Deletes a single model from the state database\n   * @summary Delegates to the repository's delete method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string | number} key - The key of the model to delete\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the deleted model\n   */\n  async delete(\n    ctx: Ctx | FabricContractContext,\n    key: PrimaryKeyType | string,\n    ...args: any[]\n  ): Promise<M | string> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.delete);\n    log.info(`deleting entry with pk ${key} `);\n    return this.repo.delete(String(key), ...ctxArgs);\n  }\n\n  /**\n   * @description Deletes multiple models from the state database\n   * @summary Delegates to the repository's deleteAll method\n   * @param {string[] | number[]} keys - The keys of the models to delete\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the deleted models\n   */\n  async deleteAll(\n    ctx: Ctx | FabricContractContext,\n    keys: PrimaryKeyType[] | string,\n    ...args: any[]\n  ): Promise<M[] | string> {\n    const { ctxArgs } = await this.logCtx([...args, ctx], this.readAll);\n    if (typeof keys === \"string\") keys = JSON.parse(keys) as string[];\n    return this.repo.deleteAll(keys, ...ctxArgs);\n  }\n\n  /**\n   * @description Reads multiple models from the state database\n   * @summary Delegates to the repository's readAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string[] | number[]} keys - The keys of the models to read\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the retrieved models\n   */\n  async readAll(\n    ctx: Ctx | FabricContractContext,\n    keys: PrimaryKeyType[] | string,\n    ...args: any[]\n  ): Promise<M[] | string> {\n    const { ctxArgs } = await this.logCtx([...args, ctx], this.readAll);\n    if (typeof keys === \"string\") keys = JSON.parse(keys) as string[];\n    return this.repo.readAll(keys, ...ctxArgs);\n  }\n\n  /**\n   * @description Updates multiple models in the state database\n   * @summary Delegates to the repository's updateAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M[]} models - The models to update\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the updated models\n   */\n  async updateAll(\n    ctx: Ctx | FabricContractContext,\n    models: string | M[],\n    ...args: any[]\n  ): Promise<string | M[]> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.updateAll);\n    if (typeof models === \"string\")\n      models = (JSON.parse(models) as [])\n        .map((m) => this.deserialize(m))\n        .map((m) => new this.clazz(m)) as any;\n\n    log.info(`updating ${models.length} entries to the table`);\n    return this.repo.updateAll(models as unknown as M[], ...ctxArgs);\n  }\n\n  /**\n   * @description Executes a query with the specified conditions and options.\n   * @summary Provides a simplified way to query the database with common query parameters.\n   * @param {Condition<M>} condition - The condition to filter records.\n   * @param orderBy - The field to order results by.\n   * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.\n   * @param {number} [limit] - Optional maximum number of results to return.\n   * @param {number} [skip] - Optional number of results to skip.\n   * @return {Promise<M[]>} The query results as model instances.\n   */\n  async query(\n    context: Ctx | FabricContractContext,\n    condition: Condition<M> | string,\n    orderBy: string | keyof M,\n    order: OrderDirection | string = OrderDirection.ASC,\n    limit?: number,\n    skip?: number,\n    ...args: any[]\n  ): Promise<M[] | string> {\n    const { ctxArgs } = await this.logCtx([...args, context], this.query);\n    return this.repo.query(\n      condition as Condition<M>,\n      orderBy as keyof M,\n      order as OrderDirection,\n      limit,\n      skip,\n      ...ctxArgs\n    );\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Delegates to the repository's raw method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {any} rawInput - The query to execute\n   * @param {boolean} docsOnly - Whether to return only documents\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<any>} Promise resolving to the query results\n   */\n  async raw(\n    ctx: Ctx | FabricContractContext,\n    rawInput: MangoQuery,\n    docsOnly: boolean,\n    ...args: any[]\n  ): Promise<any> {\n    const { ctxArgs } = await this.logCtx([...args, ctx], this.raw);\n    return FabricCrudContract.adapter.raw(rawInput, docsOnly, ...ctxArgs);\n  }\n\n  protected serialize(model: M): string {\n    return FabricCrudContract.serializer.serialize(model);\n  }\n\n  protected deserialize<M extends Model>(str: string): M {\n    return (\n      FabricCrudContract.serializer as unknown as Serializer<M>\n    ).deserialize(str);\n  }\n\n  protected async init(ctx: Ctx | FabricContractContext): Promise<void> {\n    const { log } = await this.logCtx([ctx], this.init);\n    log.info(`Running contract ${this.getName()} initialization...`);\n    this.initialized = true;\n    log.info(`Contract initialization completed.`);\n  }\n\n  async healthcheck(\n    ctx: Ctx | FabricContractContext\n  ): Promise<string | healthcheck> {\n    const { log } = await this.logCtx([ctx], this.healthcheck);\n    log.info(`Running Healthcheck: ${this.initialized}...`);\n    return { healthcheck: this.initialized };\n  }\n\n  /**\n   * @description Creates multiple models in the state database\n   * @summary Delegates to the repository's createAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M[]} models - The models to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the created models\n   */\n  async createAll(\n    ctx: Ctx | FabricContractContext,\n    models: string | M[],\n    ...args: any[]\n  ): Promise<string | M[]> {\n    const { log, ctxArgs } = await this.logCtx([...args, ctx], this.createAll);\n\n    if (typeof models === \"string\")\n      models = (JSON.parse(models) as [])\n        .map((m) => this.deserialize(m))\n        .map((m) => new this.clazz(m)) as any;\n\n    log.info(`adding ${models.length} entries to the table`);\n    return this.repo.createAll(models as unknown as M[], ...ctxArgs);\n  }\n\n  async logCtx<ARGS extends any[]>(\n    args: ARGS,\n    method: ((...args: any[]) => any) | string\n  ): Promise<\n    ContextualizedArgs<FabricContractContext, ARGS> & {\n      stub: ChaincodeStub;\n      identity: ClientIdentity;\n    }\n  > {\n    return FabricCrudContract.logCtx.bind(this)(args, method as any);\n  }\n\n  protected static async logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: string\n  ): Promise<\n    ContextualizedArgs<FabricContractContext, ARGS> & {\n      stub: ChaincodeStub;\n      identity: ClientIdentity;\n    }\n  >;\n  protected static async logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: (...args: any[]) => any\n  ): Promise<\n    ContextualizedArgs<FabricContractContext, ARGS> & {\n      stub: ChaincodeStub;\n      identity: ClientIdentity;\n    }\n  >;\n  protected static async logCtx<ARGS extends any[]>(\n    this: any,\n    args: ARGS,\n    method: ((...args: any[]) => any) | string\n  ): Promise<\n    ContextualizedArgs<FabricContractContext, ARGS> & {\n      stub: ChaincodeStub;\n      identity: ClientIdentity;\n    }\n  > {\n    if (args.length < 1) throw new InternalError(\"No context provided\");\n    const ctx = args.pop() as FabricContractContext | Context;\n    if (ctx instanceof FabricContractContext)\n      return {\n        ctx,\n        log: ctx.logger.clear().for(this).for(method),\n        ctxArgs: [...args, ctx],\n        stub: ctx.stub,\n        identity: ctx.identity,\n      };\n\n    if (!(ctx instanceof Ctx))\n      throw new InternalError(\"No valid context provided\");\n\n    function getOp() {\n      if (typeof method === \"string\") return method;\n      switch (method.name) {\n        case OperationKeys.CREATE:\n        case OperationKeys.READ:\n        case OperationKeys.UPDATE:\n        case OperationKeys.DELETE:\n        case BulkCrudOperationKeys.CREATE_ALL:\n        case BulkCrudOperationKeys.READ_ALL:\n        case BulkCrudOperationKeys.UPDATE_ALL:\n        case BulkCrudOperationKeys.DELETE_ALL:\n          return method.name;\n        default:\n          return method.name;\n      }\n    }\n\n    const overrides = {\n      correlationId: ctx.stub.getTxID(),\n    };\n    const context = await FabricCrudContract.adapter.context(\n      getOp(),\n      overrides as any,\n      this.clazz,\n      ctx\n    );\n\n    const log = (\n      this\n        ? context.logger.for(this).for(method)\n        : context.logger.clear().for(this).for(method)\n    ) as LoggerOf<FabricContractContext>;\n    return {\n      ctx: context,\n      log: log,\n      stub: context.stub,\n      identity: context.identity,\n      ctxArgs: [...args, context],\n    };\n  }\n}\n","import { FabricCrudContract } from \"./crud-contract\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Context as Ctx, Transaction } from \"fabric-contract-api\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Condition, MaybeContextualArg, OrderDirection } from \"@decaf-ts/core\";\nimport { SerializationError } from \"@decaf-ts/db-decorators\";\nimport { FabricContractContext } from \"../ContractContext\";\n\n/**\n * @description CRUD contract variant that serializes/deserializes payloads\n * @summary Exposes the same CRUD operations as FabricCrudContract but takes and returns JSON strings to facilitate simple client interactions.\n * @template M - Model type handled by this contract\n * @param {string} name - The contract name\n * @param {Constructor<M>} clazz - The model constructor used to instantiate models from JSON\n * @return {void}\n * @class SerializedCrudContract\n * @example\n * const contract = new SerializedCrudContract<MyModel>('MyModelContract', MyModel);\n * // Client submits JSON string payloads and receives JSON string responses\n */\nexport class SerializedCrudContract<\n  M extends Model,\n> extends FabricCrudContract<M> {\n  constructor(name: string, clazz: Constructor<M>) {\n    super(name, clazz);\n  }\n\n  @Transaction()\n  override async create(context: Ctx, model: string): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.create);\n    log.info(`Creating model: ${model}`);\n\n    const m = this.deserialize<M>(model);\n\n    log.info(`Model deserialized: ${JSON.stringify(m)}`);\n    const result = await super.create(ctx as any, m);\n\n    const serialized = this.serialize(result as M);\n    log.info(`RESULT: ${JSON.stringify(result)}`);\n    log.info(`Retuning: ${serialized}`);\n    return serialized;\n  }\n\n  @Transaction(false)\n  override async read(context: Ctx, key: string): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.read);\n    log.info(`Reading id: ${key}`);\n    return this.serialize((await super.read(ctx as any, key)) as M);\n  }\n\n  @Transaction()\n  override async update(context: Ctx, model: string): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.update);\n    log.info(`Updating model: ${model}`);\n    return this.serialize((await super.update(ctx as any, model)) as M);\n  }\n\n  @Transaction()\n  override async delete(context: Ctx, key: string): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.delete);\n    log.info(`Deleting id: ${key}`);\n    return this.serialize((await super.delete(ctx as any, key)) as M);\n  }\n\n  @Transaction()\n  override async deleteAll(context: Ctx, keys: string): Promise<string> {\n    const parsedKeys: string[] = JSON.parse(keys);\n    const { log, ctx } = await this.logCtx([context], this.deleteAll);\n\n    log.info(`deleting ${parsedKeys.length} entries from the table`);\n\n    return JSON.stringify(\n      ((await super.deleteAll(ctx as any, parsedKeys)) as M[]).map(\n        (m) => this.serialize(m) as string\n      )\n    );\n  }\n\n  @Transaction(false)\n  override async readAll(context: Ctx, keys: string): Promise<string> {\n    const parsedKeys: string[] = JSON.parse(keys);\n\n    const { log, ctx } = await this.logCtx([context], this.readAll);\n    log.info(`reading ${parsedKeys.length} entries from the table`);\n\n    return JSON.stringify(\n      ((await super.readAll(ctx as any, parsedKeys)) as M[]).map((m) =>\n        this.serialize(m)\n      )\n    );\n  }\n\n  @Transaction()\n  override async updateAll(context: Ctx, models: string): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.updateAll);\n    const list: string[] = JSON.parse(models);\n    const modelList: M[] = list\n      .map((m) => this.deserialize(m))\n      .map((m) => new this.clazz(m));\n\n    log.info(`Updating ${modelList.length} entries to the table`);\n    return JSON.stringify(\n      ((await super.updateAll(ctx as any, modelList)) as M[]).map(\n        (m) => this.serialize(m) as string\n      )\n    );\n  }\n\n  @Transaction(false)\n  override async statement(context: Ctx, method: string, args: string) {\n    const { ctx, log } = await this.logCtx([context], this.statement);\n    try {\n      args = JSON.parse(args);\n    } catch (e: unknown) {\n      throw new SerializationError(`Invalid args: ${e}`);\n    }\n    if (!Array.isArray(args))\n      throw new SerializationError(\n        `Invalid args: ${JSON.stringify(args)}. must be an array`\n      );\n    log.info(`calling prepared statement ${method}`);\n    log.info(`with args ${args}`);\n    return JSON.stringify(await super.statement(ctx, method, ...args));\n  }\n\n  @Transaction(false)\n  override async listBy(context: Ctx, key: string, order: string) {\n    const { ctx, log } = await this.logCtx([context], this.listBy);\n    log.info(`Executing listBy with key ${key} and order ${order}`);\n    return JSON.stringify(\n      await super.listBy(ctx, key as keyof M, order as OrderDirection)\n    );\n  }\n\n  @Transaction(false)\n  override async paginateBy(\n    context: Ctx,\n    key: string,\n    order: string,\n    ref: string,\n    ...args: MaybeContextualArg<FabricContractContext>\n  ): Promise<string> {\n    const { ctx, log } = await this.logCtx([...args, context], this.paginateBy);\n    try {\n      ref = JSON.parse(ref);\n    } catch (e: unknown) {\n      throw new SerializationError(\n        `Failed to deserialize paginateBy reference: ${e}`\n      );\n    }\n    log.info(`Executing paginateBy with key ${key} and order ${order}`);\n    return JSON.stringify(\n      await super.paginateBy(ctx, key, order as any, ref as any, ...args)\n    );\n  }\n\n  @Transaction(false)\n  override async findOneBy(\n    context: Ctx,\n    key: string,\n    value: string,\n    ...args: string[]\n  ) {\n    const { ctx, log } = await this.logCtx([...args, context], this.findOneBy);\n    log.info(`Executing findOneBy with key ${key} and value ${value}`);\n    return JSON.stringify(await super.findOneBy(ctx, key, value, ...args));\n  }\n\n  // @Transaction(false)\n  override async query(\n    context: Ctx,\n    condition: string,\n    orderBy: string,\n    order: string,\n    limit?: number,\n    skip?: number\n  ): Promise<string> {\n    const { ctx, log } = await this.logCtx([context], this.query);\n\n    log.info(`Executing query orderedBy ${orderBy} and order ${order}`);\n\n    let cond: Condition<any>;\n    try {\n      cond = Condition.from(JSON.parse(condition));\n    } catch (e: unknown) {\n      throw new SerializationError(`Invalid condition: ${e}`);\n    }\n\n    log.info(`Condition: ${JSON.stringify(cond)}`);\n\n    return JSON.stringify(\n      await super.query(ctx, cond, orderBy, order as any, limit, skip)\n    );\n  }\n  //\n  // // @Transaction(false)\n  // override async raw(\n  //   context: Ctx,\n  //   rawInput: string,\n  //   docsOnly: boolean,\n  //   ...args: string[]\n  // ): Promise<any> {\n  //   const { ctx } = await this.logCtx([context], this.raw);\n  //   const parsedInput: MangoQuery = JSON.parse(rawInput);\n  //   return JSON.stringify(await super.raw(ctx, parsedInput, docsOnly, ...args));\n  // }\n\n  @Transaction()\n  override async init(ctx: Ctx): Promise<void> {\n    await super.init(ctx);\n  }\n\n  @Transaction(false)\n  override async healthcheck(context: Ctx): Promise<string> {\n    const { log, ctx } = await this.logCtx([context], this.updateAll);\n    log.debug(`Running Healthcheck: ${this.initialized}...`);\n    //TODO: TRIM NOT WORKING CHECK LATER\n    return JSON.stringify(await super.healthcheck(ctx as any));\n  }\n\n  @Transaction()\n  override async createAll(context: Ctx, models: string): Promise<string> {\n    const { log } = await this.logCtx([context], this.createAll);\n    const list: string[] = JSON.parse(models);\n    const modelList: M[] = list\n      .map((m) => this.deserialize(m))\n      .map((m) => new this.clazz(m));\n\n    log.info(`Adding ${modelList.length} entries to the table`);\n\n    const result = (await super.createAll(context, modelList)) as M[];\n    return JSON.stringify(result.map((m) => this.serialize(m) as string));\n  }\n}\n","import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { OverflowError } from \"./errors\";\nimport { ValidationError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Overflow-safe addition operation\n * @summary Adds two numbers and verifies no overflow by reverse-checking the operands\n * @param {number} a - First operand\n * @param {number} b - Second operand\n * @return {number} The sum of a and b\n * @function add\n * @throws {OverflowError} on addition overflow\n * @memberOf module:for-fabric.shared\n */\nexport function add(a: number, b: number): number {\n  const c = a + b;\n  if (a !== c - b || b !== c - a) {\n    throw new OverflowError(`Addition overflow: ${a} + ${b}`);\n  }\n  return c;\n}\n\n/**\n * @description Overflow-safe subtraction operation\n * @summary Subtracts b from a and validates no overflow by reverse-checking the operands\n * @param {number} a - Minuend\n * @param {number} b - Subtrahend\n * @return {number} The difference a - b\n * @function sub\n * @throws {OverflowError} on subtaction overflow\n * @memberOf module:for-fabric.shared\n */\nexport function sub(a: number, b: number): number {\n  const c = a - b;\n  if (a !== c + b || b !== a - c) {\n    throw new OverflowError(`Subtraction overflow: ${a} - ${b}`);\n  }\n  return c;\n}\n\n/**\n * @summary Safe Integer Parse\n *\n * @param {string} string\n *\n * @function safeParseInt\n *\n * @throws {ValidationError} if parseInt returns NaN\n *\n * @memberOf module:for-fabric.shared\n */\nexport function safeParseInt(string: string): number {\n  // Regular expression to check if string only have digits\n  const digitRegex = /^\\d+$/;\n  if (!digitRegex.test(string)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string contains digits\")\n    );\n  }\n  const parsedint = parseInt(string);\n  if (isNaN(parsedint)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string is not a parsable integer\")\n    );\n  }\n  return parsedint;\n}\n","import { BaseModel, column, pk, table } from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description ERC20 token metadata model\n * @summary Represents an ERC20 token definition within the Fabric ERC20 sample, including name, symbol, decimals, and the owning identity. Used to define the unique token managed by the contract.\n * @param {ModelArg<ERC20Token>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Token\n * @example\n * const token = new ERC20Token({ name: \"MyToken\", symbol: \"MTK\", decimals: 18, owner: \"x509::...\" });\n * // Persist through a repository: await repo.create(token, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   participant Adapter\n *   App->>Repo: create(new ERC20Token({...}), ctx)\n *   Repo->>Adapter: create(table, id=name, record, flags)\n *   Adapter-->>Repo: stored\n *   Repo-->>App: model\n */\n@table(\"erc20_tokens\")\n@model()\nexport class ERC20Token extends BaseModel {\n  @pk({ type: \"String\" })\n  /**\n   * @description Token unique name\n   * @summary Serves as the primary key for the ERC20 token definition; typically a human-readable identifier\n   */\n  name!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Owning identity of the token\n   * @summary X.509 subject or MSP identity string that denotes who owns/controls the token definition\n   */\n  owner!: string;\n  @column()\n  @required()\n  /**\n   * @description Token symbol\n   * @summary Short ticker-like symbol used to represent the token (e.g., MTK)\n   */\n  symbol!: string;\n  @column()\n  @required()\n  /**\n   * @description Decimal precision for token amounts\n   * @summary Number of digits after the decimal separator used when formatting token balances\n   */\n  decimals!: number;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 wallet model\n * @summary Represents a holder account for an ERC20 token within the Fabric network, tracking balance and token association.\n * @param {ModelArg<ERC20Wallet>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Wallet\n * @example\n * const wallet = new ERC20Wallet({ id: \"acct1\", token: \"MyToken\", balance: 1000 });\n * // Update balance via repository: await repo.update(wallet, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   App->>Repo: read(\"acct1\", ctx)\n *   Repo-->>App: ERC20Wallet\n */\n@table(\"erc20_wallets\")\n@model()\nexport class ERC20Wallet extends BaseModel {\n  @pk({ type: \"String\" })\n  /**\n   * @description Wallet unique identifier\n   * @summary Primary key for the wallet; commonly references an account or identity\n   */\n  id!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Associated token name\n   * @summary References the ERC20Token this wallet holds; maintained as a relationship for cascading updates/deletes\n   */\n  token!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Token balance for this wallet\n   * @summary Current amount of the associated token held by this wallet\n   */\n  balance!: number;\n\n  @column()\n  /**\n   * @description Captive flag or identifier\n   * @summary Optional field used by some flows to mark non-transferable funds or managed custody\n   */\n  captive!: string;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 allowance model\n * @summary Captures an approval relationship where an owner allows a spender to transfer up to a certain value from the owner's wallet.\n * @param {ModelArg<Allowance>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class Allowance\n * @example\n * const allowance = new Allowance({ owner: \"acct1\", spender: \"acct2\", value: 50 });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   App->>App: new Allowance({ owner, spender, value })\n */\n@table(\"erc20_allowances\")\n@model()\nexport class Allowance extends BaseModel {\n  @pk({ type: \"String\" })\n  /**\n   * @description Allowance unique identifier\n   * @summary Primary key for the allowance; typically a unique identifier for the approval relationship\n   */\n  @column()\n  @required()\n  /**\n   * @description Owner wallet identifier\n   * @summary Wallet that authorizes the allowance\n   */\n  owner!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Spender wallet identifier\n   * @summary Wallet allowed to spend up to the approved value from the owner\n   */\n  spender!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Approved value\n   * @summary Maximum token amount the spender may transfer on behalf of the owner\n   */\n  value!: number;\n\n  constructor(m?: ModelArg<Allowance>) {\n    super(m);\n  }\n}\n","import {\n  AuthorizationError,\n  Repo,\n  Context,\n  UnsupportedError,\n  Repository,\n} from \"@decaf-ts/core\";\nimport {\n  InternalError,\n  NotFoundError,\n  onCreate,\n  onDelete,\n  onRead,\n  onUpdate,\n  readonly,\n  transient,\n} from \"@decaf-ts/db-decorators\";\nimport { Model, required } from \"@decaf-ts/decorator-validation\";\nimport { FabricModelKeys } from \"./constants\";\nimport type { Context as HLContext } from \"fabric-contract-api\";\nimport { FabricERC20Contract } from \"../contracts/erc20/erc20contract\";\nimport {\n  apply,\n  Constructor,\n  Decoration,\n  metadata,\n  Metadata,\n  propMetadata,\n} from \"@decaf-ts/decoration\";\nimport { FabricFlags } from \"./types\";\n\n/**\n * Decorator for marking methods that require ownership authorization.\n * Checks the owner of the token before allowing the method to be executed.\n *\n * @example\n * ```typescript\n * class TokenContract extends Contract {\n *   @Owner()\n *   async Mint(ctx: Context, amount: number) {\n *     // Mint token logic\n *   }\n * }\n * ```\n *\n * @returns {MethodDecorator} A method decorator that checks ownership authorization.\n */\nexport function Owner() {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const originalMethod = descriptor.value;\n\n    descriptor.value = async function (\n      this: FabricERC20Contract,\n      ...args: any[]\n    ) {\n      const ctx: HLContext = args[0];\n      const acountId = ctx.clientIdentity.getID();\n\n      const select = await (this as FabricERC20Contract)[\n        \"tokenRepository\"\n      ].select();\n\n      const tokens = await select.execute(ctx);\n\n      if (tokens.length == 0) {\n        throw new NotFoundError(\"No tokens avaialble\");\n      }\n\n      if (tokens.length > 1) {\n        throw new NotFoundError(`To many token available : ${tokens.length}`);\n      }\n\n      if (tokens[0].owner != acountId) {\n        throw new AuthorizationError(\n          `User not authorized to run ${propertyKey} on the token`\n        );\n      }\n\n      return await originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\nexport async function ownedByOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: Context<any>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n\n  const creator = await stub.getCreator();\n  const owner = creator.mspid;\n\n  const setOwnedByKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  setOwnedByKeyValue(model, key as string, owner);\n}\n\nexport function ownedBy() {\n  const key = getFabricModelKey(FabricModelKeys.OWNEDBY);\n\n  function ownedBy() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        readonly(),\n        onCreate(ownedByOnCreate),\n        propMetadata(getFabricModelKey(FabricModelKeys.OWNEDBY), attribute)\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: ownedBy,\n      args: [],\n    })\n    .apply();\n}\n\nexport async function transactionIdOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: Context<any>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n  model[key] = stub.getTxID();\n}\n\nexport function transactionId() {\n  function transactionId() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        readonly(),\n        onCreate(transactionIdOnCreate),\n        onUpdate(transactionIdOnCreate),\n        propMetadata(\n          Metadata.key(\n            FabricModelKeys.FABRIC,\n            attribute,\n            FabricModelKeys.TRANSACTION_ID\n          ),\n          attribute\n        )\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(FabricModelKeys.TRANSACTION_ID)\n    .define({\n      decorator: transactionId,\n      args: [],\n    })\n    .apply();\n}\n\nexport function getFabricModelKey(key: string) {\n  return Metadata.key(FabricModelKeys.FABRIC + key);\n}\n\nexport type CollectionResolver = <M extends Model>(model: M) => string;\n\nexport const ImplicitPrivateCollection: CollectionResolver = <M extends Model>(\n  model: M\n) => {\n  return `__${model.constructor.name}PrivateCollection`;\n};\n\nexport type SegregatedDataMetadata = {\n  collections: string | CollectionResolver;\n};\n\nexport async function segregatedDataOnCreate<M extends Model>(\n  this: Repository<M, any>,\n  context: Context<FabricFlags>,\n  data: SegregatedDataMetadata[],\n  keys: (keyof M)[],\n  model: M\n): Promise<void> {\n  if (keys.length !== data.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const collectionResolver = data[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model);\n\n  const rebuilt = keys.reduce(\n    (acc: Record<keyof M, any>, k, i) => {\n      const c =\n        typeof data[i].collections === \"string\"\n          ? data[i].collections\n          : data[i].collections(model);\n      if (c !== collection)\n        throw new UnsupportedError(\n          `Segregated data collection mismatch: ${c} vs ${collection}`\n        );\n      acc[k] = model[k];\n      return acc;\n    },\n    {} as Record<keyof M, any>\n  );\n\n  const toCreate = new this.class(rebuilt);\n\n  // const segregated = Model.segregate(model);\n\n  const created = await this.override({ segregated: collection } as any).create(\n    toCreate,\n    context\n  );\n  Object.assign(model, created);\n}\n\nexport async function segregatedDataOnRead<M extends Model>(\n  this: Repository<M, any>,\n  context: Context<FabricFlags>,\n  data: SegregatedDataMetadata[],\n  keys: (keyof M)[],\n  model: M\n): Promise<void> {\n  if (keys.length !== data.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const collectionResolver = data[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model);\n\n  const rebuilt = keys.reduce(\n    (acc: Record<keyof M, any>, k, i) => {\n      const c =\n        typeof data[i].collections === \"string\"\n          ? data[i].collections\n          : data[i].collections(model);\n      if (c !== collection)\n        throw new UnsupportedError(\n          `Segregated data collection mismatch: ${c} vs ${collection}`\n        );\n      acc[k] = model[k];\n      return acc;\n    },\n    {} as Record<keyof M, any>\n  );\n\n  const toCreate = new this.class(rebuilt);\n\n  // const segregated = Model.segregate(model);\n\n  const created = await this.override({ segregated: collection } as any).create(\n    toCreate,\n    context\n  );\n  Object.assign(model, created);\n}\n\nexport async function segregatedDataOnUpdate<M extends Model>(\n  this: Repository<M, any>,\n  context: Context<FabricFlags>,\n  data: SegregatedDataMetadata[],\n  key: keyof M[],\n  model: M,\n  oldModel: M\n): Promise<void> {}\n\nexport async function segregatedDataOnDelete<\n  M extends Model,\n  R extends Repository<M, any>,\n  V extends SegregatedDataMetadata,\n>(\n  this: R,\n  context: Context<FabricFlags>,\n  data: V[],\n  key: keyof M[],\n  model: M\n): Promise<void> {}\n\nfunction segregated(\n  collection: string | CollectionResolver,\n  type: FabricModelKeys.PRIVATE | FabricModelKeys.SHARED\n) {\n  return function innerSegregated(target: object, propertyKey?: any) {\n    function segregatedDec(target: object, propertyKey?: any) {\n      if (!propertyKey) {\n        const props = Metadata.properties(target as Constructor) || [];\n        for (const prop of props) segregated(collection, type)(target, prop);\n        return target;\n      }\n\n      const key = Metadata.key(type, propertyKey);\n      const constr: Constructor = target.constructor as Constructor;\n\n      const meta = Metadata.get(constr as Constructor, key) || {};\n      const collections = new Set(meta.collections || []);\n      collections.add(collection);\n      meta.collections = [...collections];\n      Metadata.set(constr as Constructor, key, meta);\n    }\n    const decs: any[] = [];\n    if (!propertyKey) {\n      // decorated at the class level\n      Metadata.properties(target as Constructor)?.forEach((p) =>\n        segregated(collection, type)(target, p)\n      );\n      return metadata(type, true)(target);\n    } else {\n      decs.push(\n        transient(),\n        segregatedDec,\n        onCreate(\n          segregatedDataOnCreate,\n          { collections: collection },\n          {\n            priority: 95,\n            group:\n              typeof collection === \"string\"\n                ? collection\n                : collection.toString(),\n          }\n        ),\n        onRead(\n          segregatedDataOnRead as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group:\n              typeof collection === \"string\"\n                ? collection\n                : collection.toString(),\n          }\n        ),\n        onUpdate(\n          segregatedDataOnUpdate as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group:\n              typeof collection === \"string\"\n                ? collection\n                : collection.toString(),\n          }\n        ),\n        onDelete(\n          segregatedDataOnDelete as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group:\n              typeof collection === \"string\"\n                ? collection\n                : collection.toString(),\n          }\n        )\n      );\n    }\n    return apply(...decs)(target, propertyKey);\n    // return apply()(target, propertyKey);\n  };\n}\n\nexport function privateData(\n  collection: string | CollectionResolver = ImplicitPrivateCollection\n) {\n  function privateData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.PRIVATE);\n  }\n\n  return Decoration.for(FabricModelKeys.PRIVATE)\n    .define({\n      decorator: privateData,\n      args: [collection],\n    })\n    .apply();\n}\n\nexport function sharedData(collection: string | CollectionResolver) {\n  function sharedData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.SHARED);\n  }\n\n  return Decoration.for(FabricModelKeys.SHARED)\n    .define({\n      decorator: sharedData,\n      args: [collection],\n    })\n    .apply();\n}\n//\n// export function privateData(collection?: string) {\n//   if (!collection) {\n//     throw new Error(\"Collection name is required\");\n//   }\n//\n//   const key: string = FabricModelKeys.PRIVATE;\n//\n//   return function privateData<M extends Model>(\n//     model: M | Constructor<M>,\n//     attribute?: any\n//   ) {\n//     const constr =\n//       model instanceof Model ? (model.constructor as Constructor) : model;\n//\n//     const metaData: any = Metadata.get(constr);\n//     const modeldata = metaData?.private?.collections || [];\n//\n//     propMetadata(key, {\n//       ...(!attribute && {\n//         collections: modeldata\n//           ? [...new Set([...modeldata, collection])]\n//           : [collection],\n//       }),\n//       isPrivate: !attribute,\n//     })(attribute ? constr : model);\n//\n//     if (attribute) {\n//       const attributeData =\n//         (metaData?.private?.[attribute] as any)?.collections || [];\n//       propMetadata(Metadata.key(key, attribute), {\n//         collections: attributeData\n//           ? [...new Set([...attributeData, collection])]\n//           : [collection],\n//       })(model, attribute);\n//       transient()(model, attribute);\n//     }\n//   };\n// }\n","/**\n * Enum representing the events emitted by an ERC20 contract.\n *\n * @remarks\n * This enum is used to identify the specific events that can be emitted by an ERC20 contract.\n * The events are named according to the EIP-20 standard.\n */\nexport enum ERC20Events {\n  /**\n   * Emitted when a `transfer` function is called successfully.\n   *\n   * @param from - The address of the sender.\n   * @param to - The address of the recipient.\n   * @param value - The amount of tokens transferred.\n   */\n  TRANSFER = \"Transfer\",\n\n  /**\n   * Emitted when an `approve` function is called successfully.\n   *\n   * @param owner - The address of the token owner.\n   * @param spender - The address of the approved spender.\n   * @param value - The amount of tokens approved for the spender.\n   */\n  APPROVAL = \"Approval\",\n}\n","import { AuthorizationError, Condition } from \"@decaf-ts/core\";\nimport { Context, Transaction } from \"fabric-contract-api\";\nimport { add, sub } from \"../../shared/math\";\nimport {\n  AllowanceError,\n  BalanceError,\n  NotInitializedError,\n} from \"../../shared/errors\";\nimport { FabricContractAdapter } from \"../ContractAdapter\";\nimport { Allowance, ERC20Token, ERC20Wallet } from \"./models\";\nimport { Owner } from \"../../shared/decorators\";\nimport { FabricContractRepository } from \"../FabricContractRepository\";\nimport type { FabricContractContext } from \"../ContractContext\";\nimport {\n  BaseError,\n  InternalError,\n  NotFoundError,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { FabricCrudContract } from \"../crud/crud-contract\";\nimport { FabricContractRepositoryObservableHandler } from \"../FabricContractRepositoryObservableHandler\";\nimport { ERC20Events } from \"../../shared/erc20/erc20-constants\";\n\n/**\n * @description ERC20 token contract base for Hyperledger Fabric\n * @summary Implements ERC20-like token logic using repositories and adapters, providing standard token operations such as balance queries, transfers, approvals, minting and burning.\n * @param {string} name - The contract name used to scope token identity\n * @note https://eips.ethereum.org/EIPS/eip-20\n * @return {void}\n * @class FabricERC20Contract\n * @example\n * class MyTokenContract extends FabricERC20Contract {\n *   constructor() { super('MyToken'); }\n * }\n * // The contract exposes methods like Transfer, Approve, Mint, Burn, etc.\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Contract\n *   participant WalletRepo\n *   participant TokenRepo\n *   participant Ledger\n *   Client->>Contract: Transfer(ctx, to, value)\n *   Contract->>WalletRepo: read(from)\n *   Contract->>WalletRepo: read(to)\n *   Contract->>Ledger: putState(updated balances)\n *   Contract-->>Client: success\n */\nexport abstract class FabricERC20Contract extends FabricCrudContract<ERC20Wallet> {\n  private walletRepository: FabricContractRepository<ERC20Wallet>;\n\n  private tokenRepository: FabricContractRepository<ERC20Token>;\n\n  private allowanceRepository: FabricContractRepository<Allowance>;\n\n  protected constructor(name: string) {\n    super(name, ERC20Wallet);\n\n    FabricERC20Contract.adapter =\n      FabricERC20Contract.adapter || new FabricContractAdapter();\n\n    this.walletRepository = FabricContractRepository.forModel(\n      ERC20Wallet,\n      FabricERC20Contract.adapter.alias\n    );\n\n    this.tokenRepository = FabricContractRepository.forModel(\n      ERC20Token,\n      FabricERC20Contract.adapter.alias\n    );\n\n    this.allowanceRepository = FabricContractRepository.forModel(\n      Allowance,\n      FabricERC20Contract.adapter.alias\n    );\n  }\n\n  @Transaction(false)\n  async TokenName(context: Context): Promise<string> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const select = this.tokenRepository.select();\n    const token = (await select.execute(ctx))[0];\n\n    return token.name;\n  }\n\n  /**\n   * Return the symbol of the token. E.g. “HIX”.\n   *\n   * @param {Context} context the transaction context\n   * @returns {String} Returns the symbol of the token\n   */\n  @Transaction(false)\n  async Symbol(context: Context): Promise<string> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const select = this.tokenRepository.select();\n    const token = (await select.execute(ctx))[0];\n\n    return token.symbol;\n  }\n\n  /**\n   * Return the number of decimals the token uses\n   * e.g. 8, means to divide the token amount by 100000000 to get its user representation.\n   *\n   * @param {Context} context the transaction context\n   * @returns {Number} Returns the number of decimals\n   */\n  @Transaction(false)\n  async Decimals(context: Context): Promise<number> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const select = this.tokenRepository.select();\n    const token = (await select.execute(ctx))[0];\n\n    return token.decimals;\n  }\n\n  /**\n   * Return the total token supply.\n   *\n   * @param {Context} context the transaction context\n   * @returns {Number} Returns the total token supply\n   */\n  @Transaction(false)\n  async TotalSupply(context: Context): Promise<number> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const select = this.walletRepository.select();\n    const wallets = await select.execute(ctx);\n\n    if (wallets.length == 0) {\n      throw new NotFoundError(`The token ${this.getName()} does not exist`);\n    }\n\n    let total = 0;\n\n    wallets.forEach((wallet) => {\n      total += wallet.balance;\n    });\n\n    return total;\n  }\n\n  /**\n   * BalanceOf returns the balance of the given account.\n   *\n   * @param {Context} ctx the transaction context\n   * @param {String} owner The owner from which the balance will be retrieved\n   * @returns {Number} Returns the account balance\n   */\n  @Transaction(false)\n  async BalanceOf(context: Context, owner: string): Promise<number> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const wallet = await this.walletRepository.read(owner, ctx);\n\n    return wallet.balance;\n  }\n\n  /**\n   * @summary Transfer transfers tokens from client account to recipient account.\n   * @description recipient account must be a valid clientID as returned by the ClientAccountID() function.\n   *\n   * @param {Context} context the transaction context\n   * @param {String} to The recipient\n   * @param {number} value The amount of token to be transferred\n   *\n   * @returns {Boolean} Return whether the transfer was successful or not\n   */\n  @Transaction()\n  async Transfer(\n    context: Context,\n    to: string,\n    value: number\n  ): Promise<boolean> {\n    // Check contract options are already set first to execute the function\n    const { ctx } = await this.logCtx([context], this.Transfer);\n    await this.CheckInitialized(ctx as any);\n\n    const from = ctx.identity.getID();\n\n    const transferResp = await this._transfer(from, to, value, ctx);\n    if (!transferResp) {\n      throw new InternalError(\"Failed to transfer\");\n    }\n\n    return true;\n  }\n\n  /**\n   * Transfer `value` amount of tokens from `from` to `to`.\n   *\n   * @param {Context} context the transaction context\n   * @param {String} from The sender\n   * @param {String} to The recipient\n   * @param {number} value The amount of token to be transferred\n   * @returns {Boolean} Return whether the transfer was successful or not\n   */\n  @Transaction()\n  async TransferFrom(\n    context: Context,\n    from: string,\n    to: string,\n    value: number\n  ): Promise<boolean> {\n    // Check contract options are already set first to execute the function\n    const { ctx } = await this.logCtx([context], this.BurnFrom);\n    await this.CheckInitialized(ctx as any);\n\n    // Retrieve the allowance of the spender\n\n    const spender = ctx.identity.getID();\n\n    const allowance = await this._getAllowance(from, spender, ctx);\n    if (!allowance || allowance.value < 0) {\n      throw new AllowanceError(\n        `spender ${spender} has no allowance from ${from}`\n      );\n    }\n\n    const currentAllowance = allowance.value;\n\n    // Check if the transferred value is less than the allowance\n    if (currentAllowance < value) {\n      throw new BalanceError(\n        \"The spender does not have enough allowance to spend.\"\n      );\n    }\n\n    // Decrease the allowance\n    const updatedAllowance = sub(currentAllowance, value);\n    const newAllowance = Object.assign({}, allowance, {\n      value: updatedAllowance,\n    });\n\n    await this.allowanceRepository.update(newAllowance, ctx);\n\n    //Realize the transfer\n    const transferResp = await this._transfer(from, to, value, ctx);\n    if (!transferResp) {\n      throw new InternalError(\"Failed to transfer\");\n    }\n\n    return true;\n  }\n\n  async _transfer(\n    from: string,\n    to: string,\n    value: number,\n    ctx: FabricContractContext\n  ) {\n    const log = ctx.logger;\n\n    if (from === to) {\n      throw new AuthorizationError(\n        \"cannot transfer to and from same client account\"\n      );\n    }\n\n    if (value < 0) {\n      // transfer of 0 is allowed in ERC20, so just validate against negative amounts\n      throw new BalanceError(\"transfer amount cannot be negative\");\n    }\n\n    // Retrieve the current balance of the sender\n\n    const fromWallet = await this.walletRepository.read(from, ctx);\n\n    const fromBalance = fromWallet.balance;\n\n    // Check if the sender has enough tokens to spend.\n    if (fromBalance < value) {\n      throw new BalanceError(`client account ${from} has insufficient funds.`);\n    }\n\n    // Retrieve the current balance of the recepient\n\n    let toWallet: ERC20Wallet;\n    let newToWallet: boolean = false;\n    try {\n      toWallet = await this.walletRepository.read(to, ctx);\n    } catch (e: unknown) {\n      if (e instanceof BaseError) {\n        if (e.code === 404) {\n          // Create a new wallet for the minter\n          toWallet = new ERC20Wallet({\n            id: to,\n            balance: 0,\n            token: await this.TokenName(ctx as any),\n          });\n          newToWallet = true;\n        } else {\n          throw new InternalError(e.message);\n        }\n      } else {\n        throw new InternalError(e as string);\n      }\n    }\n\n    const toBalance = toWallet.balance;\n\n    // Update the balance\n    const fromUpdatedBalance = sub(fromBalance, value);\n    const toUpdatedBalance = add(toBalance, value);\n\n    const updatedFromWallet = Object.assign({}, fromWallet, {\n      balance: fromUpdatedBalance,\n    });\n\n    await this.walletRepository.update(updatedFromWallet, ctx);\n\n    const updatedToWallet = Object.assign({}, toWallet, {\n      balance: toUpdatedBalance,\n    });\n\n    if (newToWallet) {\n      await this.walletRepository.create(updatedToWallet, ctx);\n    } else {\n      await this.walletRepository.update(updatedToWallet, ctx);\n    }\n\n    // Emit the Transfer event\n    const transferEvent = { from, to, value: value };\n\n    this.repo\n      .refresh(\n        ERC20Token as any,\n        ERC20Events.TRANSFER,\n        \"\",\n        transferEvent,\n        ctx as unknown as FabricContractContext\n      )\n      .catch((e) => log.error(`Failed to notify transfer: ${e}`));\n\n    return true;\n  }\n\n  /**\n   * Allows `spender` to spend `value` amount of tokens from the owner. New Approve calls override the previous allowance.\n   * @note https://eips.ethereum.org/EIPS/eip-20\n   *\n   * @param {Context} ctx the transaction context\n   * @param {String} spender The spender\n   * @param {number} value The amount of tokens to be approved for transfer\n   * @returns {Boolean} Return whether the approval was successful or not\n   */\n  @Transaction()\n  async Approve(\n    context: Context,\n    spender: string,\n    value: number\n  ): Promise<boolean> {\n    const { ctx, ctxArgs } = await this.logCtx([context], this.Approve);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const owner = ctx.identity.getID();\n\n    let allowance = await this._getAllowance(owner, spender, ctx);\n\n    const ownerWallet = await this.walletRepository.read(owner, ...ctxArgs);\n\n    if (ownerWallet.balance < value) {\n      throw new BalanceError(`client account ${owner} has insufficient funds.`);\n    }\n\n    if (allowance) {\n      // Overwrite the allowance\n      allowance.value = value;\n      await this.allowanceRepository.update(allowance, ...ctxArgs);\n    } else {\n      allowance = new Allowance({\n        owner: owner,\n        spender: spender,\n        value: value,\n      });\n\n      await this.allowanceRepository.create(allowance, ...ctxArgs);\n    }\n\n    // Emit the Approval event\n    const approvalEvent = { owner, spender, value: value };\n    this.repo.refresh(\n      ERC20Token as any,\n      ERC20Events.APPROVAL,\n      \"\",\n      approvalEvent,\n      ctx as unknown as FabricContractContext\n    );\n\n    return true;\n  }\n\n  /**\n   * Returns the amount of tokens which ` ` is allowed to withdraw from `owner`.\n   *\n   * @param {Context} ctx the transaction context\n   * @param {String} owner The owner of tokens\n   * @param {String} spender The spender who are able to transfer the tokens\n   * @returns {number} Return the amount of remaining tokens allowed to spent\n   */\n  @Transaction(false)\n  async Allowance(\n    context: Context,\n    owner: string,\n    spender: string\n  ): Promise<number> {\n    const { ctx } = await this.logCtx([context], this.Allowance);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const allowance = await this._getAllowance(owner, spender, ctx);\n\n    if (!allowance) {\n      throw new AllowanceError(\n        `spender ${spender} has no allowance from ${owner}`\n      );\n    }\n    return allowance.value;\n  }\n\n  async _getAllowance(\n    owner: string,\n    spender: string,\n    ctx: FabricContractContext\n  ): Promise<Allowance> {\n    const allowanceCondition = Condition.and(\n      Condition.attribute<Allowance>(\"owner\").eq(owner),\n      Condition.attribute<Allowance>(\"spender\").eq(spender)\n    );\n\n    const allowance = await this.allowanceRepository\n      .select()\n      .where(allowanceCondition)\n      .execute(ctx);\n    return allowance?.[0];\n  }\n\n  // ================== Extended Functions ==========================\n\n  /**\n   * Set optional infomation for a token.\n   *\n   * @param {Context} ctx the transaction context\n   * @param {String} name The name of the token\n   * @param {String} symbol The symbol of the token\n   * @param {String} decimals The decimals of the token\n   * @param {String} totalSupply The totalSupply of the token\n   */\n  @Transaction()\n  async Initialize(context: Context, token: ERC20Token) {\n    const { ctx } = await this.logCtx([context], this.Initialize);\n    // Check contract options are not already set, client is not authorized to change them once intitialized\n    const tokens = await this.tokenRepository.select().execute(ctx);\n    if (tokens.length > 0) {\n      throw new AuthorizationError(\n        \"contract options are already set, client is not authorized to change them\"\n      );\n    }\n\n    token.owner = ctx.identity.getID();\n\n    await this.tokenRepository.create(token, ctx);\n\n    return true;\n  }\n\n  // Checks that contract options have been already initialized\n  @Transaction(false)\n  async CheckInitialized(context: Context) {\n    const { ctx } = await this.logCtx([context], this.CheckInitialized);\n    const tokens = await this.tokenRepository.select().execute(ctx);\n    if (tokens.length == 0) {\n      throw new NotInitializedError(\n        \"contract options need to be set before calling any function, call Initialize() to initialize contract\"\n      );\n    }\n  }\n\n  /**\n   * Mint creates new tokens and adds them to minter's account balance\n   *\n   * @param {Context} context the transaction context\n   * @param {number} amount amount of tokens to be minted\n   * @returns {Object} The balance\n   */\n  @Owner()\n  @Transaction()\n  async Mint(context: Context, amount: number): Promise<void> {\n    const { ctx } = await this.logCtx([context], this.Mint);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    // Get ID of submitting client identity\n    const minter = ctx.identity.getID();\n\n    if (amount <= 0) {\n      throw new ValidationError(\"mint amount must be a positive integer\");\n    }\n\n    let minterWallet: ERC20Wallet;\n    try {\n      minterWallet = await this.walletRepository.read(minter, ctx);\n\n      const currentBalance = minterWallet.balance;\n\n      const updatedBalance = add(currentBalance, amount);\n\n      const updatedminter = Object.assign({}, minterWallet, {\n        balance: updatedBalance,\n      });\n\n      await this.walletRepository.update(updatedminter, ctx);\n    } catch (e: unknown) {\n      if (e instanceof BaseError) {\n        if (e.code === 404) {\n          // Create a new wallet for the minter\n          const newWallet = new ERC20Wallet({\n            id: minter,\n            balance: amount,\n            token: await this.TokenName(context),\n          });\n          await this.walletRepository.create(newWallet, ctx);\n        } else {\n          throw new InternalError(e.message);\n        }\n      } else {\n        throw new InternalError(e as string);\n      }\n    }\n\n    // Emit the Transfer event\n    const transferEvent = { from: \"0x0\", to: minter, value: amount };\n    const eventHandler =\n      this.repo.ObserverHandler() as FabricContractRepositoryObservableHandler;\n    eventHandler.updateObservers(\n      ERC20Token,\n      ERC20Events.TRANSFER,\n      \"\",\n      transferEvent,\n      ctx as unknown as FabricContractContext\n    );\n  }\n\n  /**\n   * Burn redeem tokens from minter's account balance\n   *\n   * @param {Context} context the transaction context\n   * @param {number} amount amount of tokens to be burned\n   * @returns {Object} The balance\n   */\n  @Owner()\n  @Transaction()\n  async Burn(context: Context, amount: number): Promise<void> {\n    const { log, ctx } = await this.logCtx([context], this.Burn);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const minter = ctx.identity.getID();\n\n    const minterWallet = await this.walletRepository.read(minter, ctx);\n\n    const currentBalance = minterWallet.balance;\n\n    if (currentBalance < amount) {\n      throw new BalanceError(`Minter has insufficient funds.`);\n    }\n\n    const updatedBalance = sub(currentBalance, amount);\n\n    const updatedminter = Object.assign({}, minterWallet, {\n      balance: updatedBalance,\n    });\n\n    await this.walletRepository.update(updatedminter, ctx);\n\n    log.info(`${amount} tokens were burned`);\n\n    // Emit the Transfer event\n    const transferEvent = { from: minter, to: \"0x0\", value: amount };\n    const eventHandler =\n      this.repo.ObserverHandler() as FabricContractRepositoryObservableHandler;\n    eventHandler.updateObservers(\n      ERC20Token,\n      ERC20Events.TRANSFER,\n      \"\",\n      transferEvent,\n      ctx as unknown as FabricContractContext\n    );\n  }\n\n  /**\n   * BurnFrom redeem tokens from account allowence and balance\n   *\n   * @param {Context} context the transaction context\n   * @param {number} account account from where tokens will be burned\n   * @param {number} amount amount of tokens to be burned\n   * @returns {Object} The balance\n   */\n  @Owner()\n  @Transaction()\n  async BurnFrom(\n    context: Context,\n    account: string,\n    amount: number\n  ): Promise<void> {\n    const { log, ctx } = await this.logCtx([context], this.BurnFrom);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    const accountWallet = await this.walletRepository.read(account, ctx);\n\n    const currentBalance = accountWallet.balance;\n\n    if (currentBalance < amount) {\n      throw new BalanceError(`${account} has insufficient funds.`);\n    }\n\n    const updatedBalance = sub(currentBalance, amount);\n\n    const updatedaccount = Object.assign({}, accountWallet, {\n      balance: updatedBalance,\n    });\n\n    await this.walletRepository.update(updatedaccount, ctx);\n\n    log.info(`${amount} tokens were burned from ${account}`);\n\n    // Emit the Transfer event\n    const transferEvent = { from: account, to: \"0x0\", value: amount };\n    const eventHandler =\n      this.repo.ObserverHandler() as FabricContractRepositoryObservableHandler;\n    eventHandler.updateObservers(\n      ERC20Token,\n      ERC20Events.TRANSFER,\n      \"\",\n      transferEvent,\n      ctx as unknown as FabricContractContext\n    );\n  }\n\n  /**\n   * ClientAccountBalance returns the balance of the requesting client's account.\n   *\n   * @param {Context} context the transaction context\n   * @returns {Number} Returns the account balance\n   */\n  @Transaction(false)\n  async ClientAccountBalance(context: Context): Promise<number> {\n    const { ctx } = await this.logCtx([context], this.TokenName);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    // Get ID of submitting client identity\n    const clientAccountID = ctx.identity.getID();\n\n    const clientWallet = await this.walletRepository.read(clientAccountID, ctx);\n\n    if (!clientWallet) {\n      throw new BalanceError(`The account ${clientAccountID} does not exist`);\n    }\n\n    return clientWallet.balance;\n  }\n\n  // ClientAccountID returns the id of the requesting client's account.\n  // In this implementation, the client account ID is the clientId itself.\n  // Users can use this function to get their own account id, which they can then give to others as the payment address\n  @Transaction(false)\n  async ClientAccountID(context: Context) {\n    const { ctx } = await this.logCtx([context], this.ClientAccountID);\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx as any);\n\n    // Get ID of submitting client identity\n    const clientAccountID = ctx.identity.getID();\n    return clientAccountID;\n  }\n}\n","import { FabricERC20Contract } from \"./erc20contract\";\n\nexport * from \"../FabricContractStatement\";\n\nexport const contracts: any[] = [FabricERC20Contract];\n","import { Metadata } from \"@decaf-ts/decoration\";\n\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["FabricContractContext","Context","constructor","super","stub","this","get","timestamp","getDateTimestamp","identity","toString","generateFabricEventName","table","event","owner","params","push","join","parseEventName","name","parts","split","length","undefined","FabricContractRepositoryObservableHandler","ObserverHandler","supportedEvents","OperationKeys","CREATE","UPDATE","DELETE","BulkCrudOperationKeys","CREATE_ALL","UPDATE_ALL","DELETE_ALL","updateObservers","clazz","id","args","log","ctx","Adapter","logCtx","payload","indexOf","debug","eventName","setEvent","Buffer","from","JSON","stringify","FabricContractRepository","Repository","adapter","trackedEvents","_overrides","Object","assign","ignoreValidation","ignoreHandlers","allowRawStatements","forcePrepareSimpleQueries","forcePrepareComplexQueries","paginateBy","key","order","ref","offset","limit","bookmark","QueryError","contextArgs","PreparedStatementKeys","PAGE_BY","class","ctxArgs","verbose","Model","tableName","paginator","override","select","where","attr","pk","gt","orderBy","paginate","paged","page","serialize","statement","statements","PersistenceKeys","STATEMENT","context","logger","info","result","e","BaseError","InternalError","FabricStatement","CouchDBStatement","raw","rawInput","results","pkAttr","fromSelector","type","Metadata","DBKeys","ID","selectSelector","map","r","processRecord","build","selectors","CouchDBKeys","TABLE","query","selector","fields","whereCondition","condition","parseCondition","Condition","and","attribute","eq","selectorKeys","keys","values","CouchDBGroupOperator","AND","reduce","accum","val","Error","k","OR","s","entries","forEach","console","warn","orderBySelector","sort","value","rec","CouchDBOperator","BIGGER","limitSelector","offsetSelector","skip","FabricContractSequence","Sequence","options","current","READ","SequenceModel","startWith","sequence","repo","read","parse","for","NotFoundError","cachedCurrent","increment","count","incrementBy","lock","execute","async","toIncrementBy","typeName","currentValue","returnAndCache","res","Promise","cache","put","performUpsert","next","update","create","incrementSerial","base","Number","BigInt","String","Serial","instance","generate","UUID","ConflictError","seq","FabricModelKeys","IdentityType","FabricFlavour","SimpleDeterministicSerializer","JSONSerializer","deserialize","str","deserialization","model","putAnchor","require","sortKeysRecursive","preSerialization","preSerialize","toSerialize","metadata","modelName","error","ModelKeys","ANCHOR","obj","Array","isArray","relations","call","ContractLogger","MiniLogger","conf","logging","getLogger","level","msg","stack","NumericLogLevels","config","method","LogLevel","silly","createLog","factory","object","Logging","setFactory","FabricContractPaginator","CouchDBPaginator","size","prepare","rawStatement","isPreparedStatement","pagePrepared","_recordCount","_totalPages","Math","ceil","validatePage","_bookmark","PagingError","docs","d","revert","parseValue","direction","OrderDirection","DSC","ASC","_currentPage","OverflowError","BalanceError","AllowanceError","RegistrationError","AuthorizationError","MissingContextError","UnauthorizedPrivateDataAccess","NotInitializedError","MissingPKCSS11Lib","EndorsementError","message","MvccReadConflictError","PhantomReadConflictError","EndorsementPolicyError","createdByOnFabricCreateUpdate","data","user","getID","UnsupportedError","pkFabricOnCreate","setPrimaryKeyValue","target","propertyKey","defineProperty","enumerable","writable","configurable","sequenceName","FabricContractAdapter","CouchDBAdapter","getClient","textDecoder","TextDecoder","serializer","repository","Paginator","scope","alias","composedKey","createCompositeKey","putState","parseError","readState","delete","deleteState","forPrivate","collection","toOverride","queryResult","queryResultPaginated","fn","Proxy","prop","receiver","includes","Reflect","apply","thisArg","argsList","putPrivateData","deletePrivateData","getPrivateData","getPrivateDataQueryResult","iterator","reachedBookmark","lastKey","recordKey","recordValue","Key","Record","close","fetchedRecordsCount","done","SerializationError","getState","getQueryResult","_id","$gt","$gte","it","getQueryResultWithPagination","mergeModels","extract","finalModel","pop","decode","buffer","flags","operation","baseFlags","segregated","correlationId","getTxID","clientIdentity","index","models","resolve","resultIterator","isHistory","allResults","jsonRes","TxId","txId","Timestamp","Value","err","docsOnly","response","Statement","createAll","tableLabel","all","i","updateAll","segregate","mappedProp","columnName","isReserved","record","transient","ob","m","createPrefix","updatePrefix","createAllPrefix","ids","records","updateAllPrefix","reason","filter","a","clear","BadRequestError","MigrationError","ObserverError","ForbiddenError","ConnectionError","decoration","Decoration","flavouredAs","CREATED_BY","define","onCreate","propMetadata","UPDATED_BY","onCreateUpdate","COLUMN","extend","FabricProperty","ValidationKeys","DATE","fabricProperty","Property","chain","constr","prototype","getPrototypeOf","c","FabricObject","setCurrent","DeterministicSerializer","self","o","bind","className","Date","FabricCrudContract","Contract","initialized","forModel","listBy","findOneBy","getTransientData","merge","transientMap","getTransient","has","deleteAll","readAll","init","getName","healthcheck","Ctx","getOp","READ_ALL","overrides","SerializedCrudContract","serialized","parsedKeys","list","modelList","cond","__decorate","Transaction","__metadata","add","b","sub","safeParseInt","string","digitRegex","test","ValidationError","stringFormat","parsedint","parseInt","isNaN","ERC20Token","BaseModel","column","required","ERC20Wallet","Allowance","Owner","descriptor","originalMethod","acountId","tokens","ownedByOnCreate","creator","getCreator","mspid","setOwnedByKeyValue","ownedBy","getFabricModelKey","OWNEDBY","readonly","decorator","transactionIdOnCreate","transactionId","onUpdate","FABRIC","TRANSACTION_ID","ImplicitPrivateCollection","segregatedDataOnCreate","collectionResolver","collections","rebuilt","acc","toCreate","created","segregatedDataOnRead","segregatedDataOnUpdate","oldModel","segregatedDataOnDelete","innerSegregated","segregatedDec","props","properties","meta","Set","set","decs","p","priority","group","onRead","onDelete","privateData","PRIVATE","sharedData","SHARED","ERC20Events","FabricERC20Contract","walletRepository","tokenRepository","allowanceRepository","TokenName","CheckInitialized","token","Symbol","symbol","Decimals","decimals","TotalSupply","wallets","total","wallet","balance","BalanceOf","Transfer","to","transferResp","_transfer","TransferFrom","BurnFrom","spender","allowance","_getAllowance","currentAllowance","updatedAllowance","newAllowance","fromWallet","fromBalance","toWallet","newToWallet","code","toBalance","fromUpdatedBalance","toUpdatedBalance","updatedFromWallet","updatedToWallet","transferEvent","refresh","TRANSFER","catch","Approve","ownerWallet","approvalEvent","APPROVAL","allowanceCondition","Initialize","Mint","amount","minter","minterWallet","currentBalance","updatedBalance","updatedminter","newWallet","eventHandler","Burn","account","accountWallet","updatedaccount","ClientAccountBalance","clientAccountID","clientWallet","ClientAccountID","contracts","VERSION","PACKAGE_NAME","registerLibrary"],"mappings":"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"}