@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/erc20/erc20contract.js

@@ -0,0 +1,565 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AuthorizationError, Condition } from "@decaf-ts/core";
+import { Context, Transaction } from "fabric-contract-api";
+import { add, sub } from "./../../shared/math.js";
+import { AllowanceError, BalanceError, NotInitializedError, } from "./../../shared/errors.js";
+import { FabricContractAdapter } from "./../ContractAdapter.js";
+import { Allowance, ERC20Token, ERC20Wallet } from "./models.js";
+import { Owner } from "./../../shared/decorators.js";
+import { FabricContractRepository } from "./../FabricContractRepository.js";
+import { BaseError, InternalError, NotFoundError, ValidationError, } from "@decaf-ts/db-decorators";
+import { FabricCrudContract } from "./../crud/crud-contract.js";
+import { ERC20Events } from "./../../shared/erc20/erc20-constants.js";
+/**
+ * @description ERC20 token contract base for Hyperledger Fabric
+ * @summary Implements ERC20-like token logic using repositories and adapters, providing standard token operations such as balance queries, transfers, approvals, minting and burning.
+ * @param {string} name - The contract name used to scope token identity
+ * @note https://eips.ethereum.org/EIPS/eip-20
+ * @return {void}
+ * @class FabricERC20Contract
+ * @example
+ * class MyTokenContract extends FabricERC20Contract {
+ *   constructor() { super('MyToken'); }
+ * }
+ * // The contract exposes methods like Transfer, Approve, Mint, Burn, etc.
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Contract
+ *   participant WalletRepo
+ *   participant TokenRepo
+ *   participant Ledger
+ *   Client->>Contract: Transfer(ctx, to, value)
+ *   Contract->>WalletRepo: read(from)
+ *   Contract->>WalletRepo: read(to)
+ *   Contract->>Ledger: putState(updated balances)
+ *   Contract-->>Client: success
+ */
+export 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(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const select = await this.tokenRepository.selectWithContext(undefined, ctx);
+        const token = (await select.execute())[0];
+        return token.name;
+    }
+    /**
+     * Return the symbol of the token. E.g. “HIX”.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {String} Returns the symbol of the token
+     */
+    async Symbol(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const select = await this.tokenRepository.selectWithContext(undefined, ctx);
+        const token = (await select.execute())[0];
+        return token.symbol;
+    }
+    /**
+     * Return the number of decimals the token uses
+     * e.g. 8, means to divide the token amount by 100000000 to get its user representation.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {Number} Returns the number of decimals
+     */
+    async Decimals(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const select = await this.tokenRepository.selectWithContext(undefined, ctx);
+        const token = (await select.execute())[0];
+        return token.decimals;
+    }
+    /**
+     * Return the total token supply.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {Number} Returns the total token supply
+     */
+    async TotalSupply(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const select = await this.walletRepository.selectWithContext(undefined, ctx);
+        const wallets = await select.execute();
+        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;
+    }
+    /**
+     * BalanceOf returns the balance of the given account.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} owner The owner from which the balance will be retrieved
+     * @returns {Number} Returns the account balance
+     */
+    async BalanceOf(ctx, owner) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const wallet = await this.walletRepository.read(owner, ctx);
+        return wallet.balance;
+    }
+    /**
+     * @summary Transfer transfers tokens from client account to recipient account.
+     * @description recipient account must be a valid clientID as returned by the ClientAccountID() function.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} to The recipient
+     * @param {number} value The amount of token to be transferred
+     *
+     * @returns {Boolean} Return whether the transfer was successful or not
+     */
+    async Transfer(ctx, to, value) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const from = ctx.clientIdentity.getID();
+        const transferResp = await this._transfer(ctx, from, to, value);
+        if (!transferResp) {
+            throw new InternalError("Failed to transfer");
+        }
+        return true;
+    }
+    /**
+     * Transfer `value` amount of tokens from `from` to `to`.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} from The sender
+     * @param {String} to The recipient
+     * @param {number} value The amount of token to be transferred
+     * @returns {Boolean} Return whether the transfer was successful or not
+     */
+    async TransferFrom(ctx, from, to, value) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        // Retrieve the allowance of the spender
+        const spender = ctx.clientIdentity.getID();
+        const allowance = await this._getAllowance(ctx, from, spender);
+        if (!allowance || allowance.value < 0) {
+            throw new AllowanceError(`spender ${spender} has no allowance from ${from}`);
+        }
+        const currentAllowance = allowance.value;
+        // Check if the transferred value is less than the allowance
+        if (currentAllowance < value) {
+            throw new BalanceError("The spender does not have enough allowance to spend.");
+        }
+        // Decrease the allowance
+        const updatedAllowance = sub(currentAllowance, value);
+        const newAllowance = Object.assign({}, allowance, {
+            value: updatedAllowance,
+        });
+        await this.allowanceRepository.update(newAllowance, ctx);
+        //Realize the transfer
+        const transferResp = await this._transfer(ctx, from, to, value);
+        if (!transferResp) {
+            throw new InternalError("Failed to transfer");
+        }
+        return true;
+    }
+    async _transfer(ctx, from, to, value) {
+        const logger = this.logFor(ctx).for(this._transfer);
+        if (from === to) {
+            throw new AuthorizationError("cannot transfer to and from same client account");
+        }
+        if (value < 0) {
+            // transfer of 0 is allowed in ERC20, so just validate against negative amounts
+            throw new BalanceError("transfer amount cannot be negative");
+        }
+        // Retrieve the current balance of the sender
+        const fromWallet = await this.walletRepository.read(from, ctx);
+        const fromBalance = fromWallet.balance;
+        // Check if the sender has enough tokens to spend.
+        if (fromBalance < value) {
+            throw new BalanceError(`client account ${from} has insufficient funds.`);
+        }
+        // Retrieve the current balance of the recepient
+        let toWallet;
+        let newToWallet = false;
+        try {
+            toWallet = await this.walletRepository.read(to, ctx);
+        }
+        catch (e) {
+            if (e instanceof BaseError) {
+                if (e.code === 404) {
+                    // Create a new wallet for the minter
+                    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;
+        // Update the 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);
+        }
+        // Emit the Transfer event
+        const transferEvent = { from, to, value: value };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(logger, "", ERC20Events.TRANSFER, "", ctx, "", transferEvent);
+        return true;
+    }
+    /**
+     * Allows `spender` to spend `value` amount of tokens from the owner. New Approve calls override the previous allowance.
+     * @note https://eips.ethereum.org/EIPS/eip-20
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} spender The spender
+     * @param {number} value The amount of tokens to be approved for transfer
+     * @returns {Boolean} Return whether the approval was successful or not
+     */
+    async Approve(ctx, spender, value) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const logger = this.logFor(ctx).for(this.Approve);
+        const owner = ctx.clientIdentity.getID();
+        let allowance = await this._getAllowance(ctx, owner, spender);
+        const ownerWallet = await this.walletRepository.read(owner, ctx);
+        if (ownerWallet.balance < value) {
+            throw new BalanceError(`client account ${owner} has insufficient funds.`);
+        }
+        if (allowance) {
+            // Overwrite the allowance
+            allowance.value = value;
+            await this.allowanceRepository.update(allowance, ctx);
+        }
+        else {
+            allowance = new Allowance({
+                owner: owner,
+                spender: spender,
+                value: value,
+            });
+            await this.allowanceRepository.create(allowance, ctx);
+        }
+        // Emit the Approval event
+        const approvalEvent = { owner, spender, value: value };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(logger, "", ERC20Events.APPROVAL, "", ctx, "", approvalEvent);
+        return true;
+    }
+    /**
+     * Returns the amount of tokens which ` ` is allowed to withdraw from `owner`.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} owner The owner of tokens
+     * @param {String} spender The spender who are able to transfer the tokens
+     * @returns {number} Return the amount of remaining tokens allowed to spent
+     */
+    async Allowance(ctx, owner, spender) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const allowance = await this._getAllowance(ctx, owner, spender);
+        if (!allowance) {
+            throw new AllowanceError(`spender ${spender} has no allowance from ${owner}`);
+        }
+        return allowance.value;
+    }
+    async _getAllowance(ctx, owner, spender) {
+        const allowanceCondition = Condition.and(Condition.attribute("owner").eq(owner), Condition.attribute("spender").eq(spender));
+        const select = await this.allowanceRepository.selectWithContext(undefined, ctx);
+        const allowance = await select.where(allowanceCondition).execute();
+        return allowance?.[0];
+    }
+    // ================== Extended Functions ==========================
+    /**
+     * Set optional infomation for a token.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} name The name of the token
+     * @param {String} symbol The symbol of the token
+     * @param {String} decimals The decimals of the token
+     * @param {String} totalSupply The totalSupply of the token
+     */
+    async Initialize(ctx, token) {
+        // Check contract options are not already set, client is not authorized to change them once intitialized
+        const select = await this.tokenRepository.selectWithContext(undefined, ctx);
+        const tokens = await select.execute();
+        if (tokens.length > 0) {
+            throw new AuthorizationError("contract options are already set, client is not authorized to change them");
+        }
+        token.owner = ctx.clientIdentity.getID();
+        await this.tokenRepository.create(token, ctx);
+        return true;
+    }
+    // Checks that contract options have been already initialized
+    async CheckInitialized(ctx) {
+        const select = await this.tokenRepository.selectWithContext(undefined, ctx);
+        const tokens = await select.execute();
+        if (tokens.length == 0) {
+            throw new NotInitializedError("contract options need to be set before calling any function, call Initialize() to initialize contract");
+        }
+    }
+    /**
+     * Mint creates new tokens and adds them to minter's account balance
+     *
+     * @param {Context} ctx the transaction context
+     * @param {number} amount amount of tokens to be minted
+     * @returns {Object} The balance
+     */
+    async Mint(ctx, amount) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const logger = this.logFor(ctx).for(this.Mint);
+        // Get ID of submitting client identity
+        const minter = ctx.clientIdentity.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) {
+                    // Create a new wallet for the minter
+                    const newWallet = new ERC20Wallet({
+                        id: minter,
+                        balance: amount,
+                        token: await this.TokenName(ctx),
+                    });
+                    await this.walletRepository.create(newWallet, ctx);
+                }
+                else {
+                    throw new InternalError(e.message);
+                }
+            }
+            else {
+                throw new InternalError(e);
+            }
+        }
+        // Emit the Transfer event
+        const transferEvent = { from: "0x0", to: minter, value: amount };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(logger, "", ERC20Events.TRANSFER, "", ctx, "", transferEvent);
+    }
+    /**
+     * Burn redeem tokens from minter's account balance
+     *
+     * @param {Context} ctx the transaction context
+     * @param {number} amount amount of tokens to be burned
+     * @returns {Object} The balance
+     */
+    async Burn(ctx, amount) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const logger = this.logFor(ctx).for(this.Burn);
+        const minter = ctx.clientIdentity.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);
+        logger.info(`${amount} tokens were burned`);
+        // Emit the Transfer event
+        const transferEvent = { from: minter, to: "0x0", value: amount };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(logger, "", ERC20Events.TRANSFER, "", ctx, "", transferEvent);
+    }
+    /**
+     * BurnFrom redeem tokens from account allowence and balance
+     *
+     * @param {Context} ctx the transaction context
+     * @param {number} account account from where tokens will be burned
+     * @param {number} amount amount of tokens to be burned
+     * @returns {Object} The balance
+     */
+    async BurnFrom(ctx, account, amount) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        const logger = this.logFor(ctx).for(this.BurnFrom);
+        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);
+        logger.info(`${amount} tokens were berned from ${account}`);
+        // Emit the Transfer event
+        const transferEvent = { from: account, to: "0x0", value: amount };
+        const eventHandler = this.repo.ObserverHandler();
+        eventHandler.updateObservers(logger, "", ERC20Events.TRANSFER, "", ctx, "", transferEvent);
+    }
+    /**
+     * ClientAccountBalance returns the balance of the requesting client's account.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {Number} Returns the account balance
+     */
+    async ClientAccountBalance(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        // Get ID of submitting client identity
+        const clientAccountID = ctx.clientIdentity.getID();
+        const clientWallet = await this.walletRepository.read(clientAccountID, ctx);
+        if (!clientWallet) {
+            throw new BalanceError(`The account ${clientAccountID} does not exist`);
+        }
+        return clientWallet.balance;
+    }
+    // ClientAccountID returns the id of the requesting client's account.
+    // In this implementation, the client account ID is the clientId itself.
+    // Users can use this function to get their own account id, which they can then give to others as the payment address
+    async ClientAccountID(ctx) {
+        // Check contract options are already set first to execute the function
+        await this.CheckInitialized(ctx);
+        // Get ID of submitting client identity
+        const clientAccountID = ctx.clientIdentity.getID();
+        return clientAccountID;
+    }
+}
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "TokenName", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Symbol", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Decimals", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "TotalSupply", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "BalanceOf", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Transfer", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String, String, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "TransferFrom", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Approve", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String, String]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Allowance", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, ERC20Token]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Initialize", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "CheckInitialized", null);
+__decorate([
+    Owner(),
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Mint", null);
+__decorate([
+    Owner(),
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "Burn", null);
+__decorate([
+    Owner(),
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context, String, Number]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "BurnFrom", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "ClientAccountBalance", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Context]),
+    __metadata("design:returntype", Promise)
+], FabricERC20Contract.prototype, "ClientAccountID", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erc20contract.js","sourceRoot":"","sources":["../../../../src/contracts/erc20/erc20contract.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,+BAA0B;AAC7C,OAAO,EACL,cAAc,EACd,YAAY,EACZ,mBAAmB,GACpB,iCAA4B;AAC7B,OAAO,EAAE,qBAAqB,EAAE,gCAA2B;AAC3D,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,oBAAiB;AAC9D,OAAO,EAAE,KAAK,EAAE,qCAAgC;AAChD,OAAO,EAAE,wBAAwB,EAAE,yCAAoC;AACvE,OAAO,EACL,SAAS,EACT,aAAa,EACb,aAAa,EACb,eAAe,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,mCAA8B;AAE3D,OAAO,EAAE,WAAW,EAAE,gDAA2C;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,OAAgB,mBAAoB,SAAQ,kBAA+B;IAO/E,YAAsB,IAAY;QAChC,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAEzB,mBAAmB,CAAC,OAAO;YACzB,mBAAmB,CAAC,OAAO,IAAI,IAAI,qBAAqB,EAAE,CAAC;QAE7D,IAAI,CAAC,gBAAgB,GAAG,wBAAwB,CAAC,QAAQ,CACvD,WAAW,EACX,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAClC,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC,QAAQ,CACtD,UAAU,EACV,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAClC,CAAC;QAEF,IAAI,CAAC,mBAAmB,GAAG,wBAAwB,CAAC,QAAQ,CAC1D,SAAS,EACT,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAClC,CAAC;IACJ,CAAC;IAGK,AAAN,KAAK,CAAC,SAAS,CAAC,GAAY;QAC1B,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IAEG,AAAN,KAAK,CAAC,MAAM,CAAC,GAAY;QACvB,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC,MAAM,CAAC;IACtB,CAAC;IAED;;;;;;OAMG;IAEG,AAAN,KAAK,CAAC,QAAQ,CAAC,GAAY;QACzB,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC,QAAQ,CAAC;IACxB,CAAC;IAED;;;;;OAKG;IAEG,AAAN,KAAK,CAAC,WAAW,CAAC,GAAY;QAC5B,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAC1D,SAAS,EACT,GAAG,CACJ,CAAC;QACF,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QAEvC,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,aAAa,CAAC,aAAa,IAAI,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACzB,KAAK,IAAI,MAAM,CAAC,OAAO,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IAEG,AAAN,KAAK,CAAC,SAAS,CAAC,GAAY,EAAE,KAAa;QACzC,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAE5D,OAAO,MAAM,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;;;;;;;;OASG;IAEG,AAAN,KAAK,CAAC,QAAQ,CAAC,GAAY,EAAE,EAAU,EAAE,KAAa;QACpD,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,IAAI,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAExC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAChE,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,aAAa,CAAC,oBAAoB,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IAEG,AAAN,KAAK,CAAC,YAAY,CAChB,GAAY,EACZ,IAAY,EACZ,EAAU,EACV,KAAa;QAEb,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,wCAAwC;QAExC,MAAM,OAAO,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAE3C,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC/D,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,cAAc,CACtB,WAAW,OAAO,0BAA0B,IAAI,EAAE,CACnD,CAAC;QACJ,CAAC;QAED,MAAM,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC;QAEzC,4DAA4D;QAC5D,IAAI,gBAAgB,GAAG,KAAK,EAAE,CAAC;YAC7B,MAAM,IAAI,YAAY,CACpB,sDAAsD,CACvD,CAAC;QACJ,CAAC;QAED,yBAAyB;QACzB,MAAM,gBAAgB,GAAG,GAAG,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE;YAChD,KAAK,EAAE,gBAAgB;SACxB,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;QAEzD,sBAAsB;QACtB,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAChE,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,aAAa,CAAC,oBAAoB,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,GAAY,EAAE,IAAY,EAAE,EAAU,EAAE,KAAa;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEpD,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;YAChB,MAAM,IAAI,kBAAkB,CAC1B,iDAAiD,CAClD,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,+EAA+E;YAC/E,MAAM,IAAI,YAAY,CAAC,oCAAoC,CAAC,CAAC;QAC/D,CAAC;QAED,6CAA6C;QAE7C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAE/D,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC;QAEvC,kDAAkD;QAClD,IAAI,WAAW,GAAG,KAAK,EAAE,CAAC;YACxB,MAAM,IAAI,YAAY,CAAC,kBAAkB,IAAI,0BAA0B,CAAC,CAAC;QAC3E,CAAC;QAED,gDAAgD;QAEhD,IAAI,QAAqB,CAAC;QAC1B,IAAI,WAAW,GAAY,KAAK,CAAC;QACjC,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QACvD,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,IAAI,CAAC,YAAY,SAAS,EAAE,CAAC;gBAC3B,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;oBACnB,qCAAqC;oBACrC,QAAQ,GAAG,IAAI,WAAW,CAAC;wBACzB,EAAE,EAAE,EAAE;wBACN,OAAO,EAAE,CAAC;wBACV,KAAK,EAAE,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;qBACjC,CAAC,CAAC;oBACH,WAAW,GAAG,IAAI,CAAC;gBACrB,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,aAAa,CAAC,CAAW,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QAED,MAAM,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC;QAEnC,qBAAqB;QACrB,MAAM,kBAAkB,GAAG,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QACnD,MAAM,gBAAgB,GAAG,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAE/C,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,UAAU,EAAE;YACtD,OAAO,EAAE,kBAAkB;SAC5B,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;QAE3D,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE;YAClD,OAAO,EAAE,gBAAgB;SAC1B,CAAC,CAAC;QAEH,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;QAC3D,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;QAC3D,CAAC;QAED,0BAA0B;QAC1B,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACjD,MAAM,YAAY,GAChB,IAAI,CAAC,IAAI,CAAC,eAAe,EAA+C,CAAC;QAC3E,YAAY,CAAC,eAAe,CAC1B,MAAM,EACN,EAAE,EACF,WAAW,CAAC,QAAQ,EACpB,EAAE,EACF,GAAG,EACH,EAAE,EACF,aAAa,CACd,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IAEG,AAAN,KAAK,CAAC,OAAO,CACX,GAAY,EACZ,OAAe,EACf,KAAa;QAEb,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAElD,MAAM,KAAK,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAEzC,IAAI,SAAS,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAE9D,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAEjE,IAAI,WAAW,CAAC,OAAO,GAAG,KAAK,EAAE,CAAC;YAChC,MAAM,IAAI,YAAY,CAAC,kBAAkB,KAAK,0BAA0B,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACd,0BAA0B;YAC1B,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC;YACxB,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QACxD,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,IAAI,SAAS,CAAC;gBACxB,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,OAAO;gBAChB,KAAK,EAAE,KAAK;aACb,CAAC,CAAC;YAEH,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QACxD,CAAC;QAED,0BAA0B;QAC1B,MAAM,aAAa,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACvD,MAAM,YAAY,GAChB,IAAI,CAAC,IAAI,CAAC,eAAe,EAA+C,CAAC;QAC3E,YAAY,CAAC,eAAe,CAC1B,MAAM,EACN,EAAE,EACF,WAAW,CAAC,QAAQ,EACpB,EAAE,EACF,GAAG,EACH,EAAE,EACF,aAAa,CACd,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IAEG,AAAN,KAAK,CAAC,SAAS,CACb,GAAY,EACZ,KAAa,EACb,OAAe;QAEf,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAEhE,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,cAAc,CACtB,WAAW,OAAO,0BAA0B,KAAK,EAAE,CACpD,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC,KAAK,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,GAAY,EACZ,KAAa,EACb,OAAe;QAEf,MAAM,kBAAkB,GAAG,SAAS,CAAC,GAAG,CACtC,SAAS,CAAC,SAAS,CAAY,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACjD,SAAS,CAAC,SAAS,CAAY,SAAS,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CACtD,CAAC;QAEF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAC7D,SAAS,EACT,GAAG,CACJ,CAAC;QACF,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,OAAO,EAAE,CAAC;QACnE,OAAO,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IAED,mEAAmE;IAEnE;;;;;;;;OAQG;IAEG,AAAN,KAAK,CAAC,UAAU,CAAC,GAAY,EAAE,KAAiB;QAC9C,wGAAwG;QACxG,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACtC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,kBAAkB,CAC1B,2EAA2E,CAC5E,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAEzC,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAE9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6DAA6D;IAEvD,AAAN,KAAK,CAAC,gBAAgB,CAAC,GAAY;QACjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACtC,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,mBAAmB,CAC3B,uGAAuG,CACxG,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IAGG,AAAN,KAAK,CAAC,IAAI,CAAC,GAAY,EAAE,MAAc;QACrC,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/C,uCAAuC;QACvC,MAAM,MAAM,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAE1C,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YAChB,MAAM,IAAI,eAAe,CAAC,wCAAwC,CAAC,CAAC;QACtE,CAAC;QAED,IAAI,YAAyB,CAAC;QAC9B,IAAI,CAAC;YACH,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAE7D,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,CAAC;YAE5C,MAAM,cAAc,GAAG,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;YAEnD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE;gBACpD,OAAO,EAAE,cAAc;aACxB,CAAC,CAAC;YAEH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,IAAI,CAAC,YAAY,SAAS,EAAE,CAAC;gBAC3B,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;oBACnB,qCAAqC;oBACrC,MAAM,SAAS,GAAG,IAAI,WAAW,CAAC;wBAChC,EAAE,EAAE,MAAM;wBACV,OAAO,EAAE,MAAM;wBACf,KAAK,EAAE,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;qBACjC,CAAC,CAAC;oBACH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;gBACrD,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,aAAa,CAAC,CAAW,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QAED,0BAA0B;QAC1B,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QACjE,MAAM,YAAY,GAChB,IAAI,CAAC,IAAI,CAAC,eAAe,EAA+C,CAAC;QAC3E,YAAY,CAAC,eAAe,CAC1B,MAAM,EACN,EAAE,EACF,WAAW,CAAC,QAAQ,EACpB,EAAE,EACF,GAAG,EACH,EAAE,EACF,aAAa,CACd,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IAGG,AAAN,KAAK,CAAC,IAAI,CAAC,GAAY,EAAE,MAAc;QACrC,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/C,MAAM,MAAM,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAE1C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEnE,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,CAAC;QAE5C,IAAI,cAAc,GAAG,MAAM,EAAE,CAAC;YAC5B,MAAM,IAAI,YAAY,CAAC,gCAAgC,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,cAAc,GAAG,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QAEnD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE;YACpD,OAAO,EAAE,cAAc;SACxB,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;QAEvD,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,qBAAqB,CAAC,CAAC;QAE5C,0BAA0B;QAC1B,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QACjE,MAAM,YAAY,GAChB,IAAI,CAAC,IAAI,CAAC,eAAe,EAA+C,CAAC;QAC3E,YAAY,CAAC,eAAe,CAC1B,MAAM,EACN,EAAE,EACF,WAAW,CAAC,QAAQ,EACpB,EAAE,EACF,GAAG,EACH,EAAE,EACF,aAAa,CACd,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IAGG,AAAN,KAAK,CAAC,QAAQ,CAAC,GAAY,EAAE,OAAe,EAAE,MAAc;QAC1D,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEnD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAErE,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,CAAC;QAE7C,IAAI,cAAc,GAAG,MAAM,EAAE,CAAC;YAC5B,MAAM,IAAI,YAAY,CAAC,GAAG,OAAO,0BAA0B,CAAC,CAAC;QAC/D,CAAC;QAED,MAAM,cAAc,GAAG,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QAEnD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,aAAa,EAAE;YACtD,OAAO,EAAE,cAAc;SACxB,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;QAExD,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,4BAA4B,OAAO,EAAE,CAAC,CAAC;QAE5D,0BAA0B;QAC1B,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAClE,MAAM,YAAY,GAChB,IAAI,CAAC,IAAI,CAAC,eAAe,EAA+C,CAAC;QAC3E,YAAY,CAAC,eAAe,CAC1B,MAAM,EACN,EAAE,EACF,WAAW,CAAC,QAAQ,EACpB,EAAE,EACF,GAAG,EACH,EAAE,EACF,aAAa,CACd,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IAEG,AAAN,KAAK,CAAC,oBAAoB,CAAC,GAAY;QACrC,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,uCAAuC;QACvC,MAAM,eAAe,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAEnD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;QAE5E,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,YAAY,CAAC,eAAe,eAAe,iBAAiB,CAAC,CAAC;QAC1E,CAAC;QAED,OAAO,YAAY,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED,qEAAqE;IACrE,wEAAwE;IACxE,qHAAqH;IAE/G,AAAN,KAAK,CAAC,eAAe,CAAC,GAAY;QAChC,uEAAuE;QACvE,MAAM,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEjC,uCAAuC;QACvC,MAAM,eAAe,GAAG,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QACnD,OAAO,eAAe,CAAC;IACzB,CAAC;CACF;AAjmBO;IADL,WAAW,CAAC,KAAK,CAAC;;qCACE,OAAO;;oDAQ3B;AASK;IADL,WAAW,CAAC,KAAK,CAAC;;qCACD,OAAO;;iDAQxB;AAUK;IADL,WAAW,CAAC,KAAK,CAAC;;qCACC,OAAO;;mDAQ1B;AASK;IADL,WAAW,CAAC,KAAK,CAAC;;qCACI,OAAO;;sDAqB7B;AAUK;IADL,WAAW,CAAC,KAAK,CAAC;;qCACE,OAAO;;oDAO3B;AAaK;IADL,WAAW,EAAE;;qCACM,OAAO;;mDAY1B;AAYK;IADL,WAAW,EAAE;;qCAEP,OAAO;;uDA2Cb;AAoGK;IADL,WAAW,EAAE;;qCAEP,OAAO;;kDA+Cb;AAWK;IADL,WAAW,EAAE;;qCAEP,OAAO;;oDAeb;AAgCK;IADL,WAAW,EAAE;;qCACQ,OAAO,EAAS,UAAU;;qDAe/C;AAIK;IADL,WAAW,CAAC,KAAK,CAAC;;qCACS,OAAO;;2DAQlC;AAWK;IAFL,KAAK,EAAE;IACP,WAAW,EAAE;;qCACE,OAAO;;+CAyDtB;AAWK;IAFL,KAAK,EAAE;IACP,WAAW,EAAE;;qCACE,OAAO;;+CAuCtB;AAYK;IAFL,KAAK,EAAE;IACP,WAAW,EAAE;;qCACM,OAAO;;mDAqC1B;AASK;IADL,WAAW,EAAE;;qCACkB,OAAO;;+DActC;AAMK;IADL,WAAW,EAAE;;qCACa,OAAO;;0DAOjC","sourcesContent":["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 {\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(ctx: Context): Promise<string> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const select = await this.tokenRepository.selectWithContext(undefined, ctx);\n    const token = (await select.execute())[0];\n\n    return token.name;\n  }\n\n  /**\n   * Return the symbol of the token. E.g. “HIX”.\n   *\n   * @param {Context} ctx the transaction context\n   * @returns {String} Returns the symbol of the token\n   */\n  @Transaction(false)\n  async Symbol(ctx: Context): Promise<string> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const select = await this.tokenRepository.selectWithContext(undefined, ctx);\n    const token = (await select.execute())[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} ctx the transaction context\n   * @returns {Number} Returns the number of decimals\n   */\n  @Transaction(false)\n  async Decimals(ctx: Context): Promise<number> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const select = await this.tokenRepository.selectWithContext(undefined, ctx);\n    const token = (await select.execute())[0];\n\n    return token.decimals;\n  }\n\n  /**\n   * Return the total token supply.\n   *\n   * @param {Context} ctx the transaction context\n   * @returns {Number} Returns the total token supply\n   */\n  @Transaction(false)\n  async TotalSupply(ctx: Context): Promise<number> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const select = await this.walletRepository.selectWithContext(\n      undefined,\n      ctx\n    );\n    const wallets = await select.execute();\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(ctx: Context, owner: string): Promise<number> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\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} ctx 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(ctx: Context, to: string, value: number): Promise<boolean> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const from = ctx.clientIdentity.getID();\n\n    const transferResp = await this._transfer(ctx, from, to, value);\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} ctx 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    ctx: 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    await this.CheckInitialized(ctx);\n\n    // Retrieve the allowance of the spender\n\n    const spender = ctx.clientIdentity.getID();\n\n    const allowance = await this._getAllowance(ctx, from, spender);\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(ctx, from, to, value);\n    if (!transferResp) {\n      throw new InternalError(\"Failed to transfer\");\n    }\n\n    return true;\n  }\n\n  async _transfer(ctx: Context, from: string, to: string, value: number) {\n    const logger = this.logFor(ctx).for(this._transfer);\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),\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    const eventHandler =\n      this.repo.ObserverHandler() as FabricContractRepositoryObservableHandler;\n    eventHandler.updateObservers(\n      logger,\n      \"\",\n      ERC20Events.TRANSFER,\n      \"\",\n      ctx,\n      \"\",\n      transferEvent\n    );\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    ctx: Context,\n    spender: string,\n    value: number\n  ): Promise<boolean> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n    const logger = this.logFor(ctx).for(this.Approve);\n\n    const owner = ctx.clientIdentity.getID();\n\n    let allowance = await this._getAllowance(ctx, owner, spender);\n\n    const ownerWallet = await this.walletRepository.read(owner, ctx);\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, ctx);\n    } else {\n      allowance = new Allowance({\n        owner: owner,\n        spender: spender,\n        value: value,\n      });\n\n      await this.allowanceRepository.create(allowance, ctx);\n    }\n\n    // Emit the Approval event\n    const approvalEvent = { owner, spender, value: value };\n    const eventHandler =\n      this.repo.ObserverHandler() as FabricContractRepositoryObservableHandler;\n    eventHandler.updateObservers(\n      logger,\n      \"\",\n      ERC20Events.APPROVAL,\n      \"\",\n      ctx,\n      \"\",\n      approvalEvent\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()\n  async Allowance(\n    ctx: Context,\n    owner: string,\n    spender: string\n  ): Promise<number> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const allowance = await this._getAllowance(ctx, owner, spender);\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    ctx: Context,\n    owner: string,\n    spender: string\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 select = await this.allowanceRepository.selectWithContext(\n      undefined,\n      ctx\n    );\n    const allowance = await select.where(allowanceCondition).execute();\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(ctx: Context, token: ERC20Token) {\n    // Check contract options are not already set, client is not authorized to change them once intitialized\n    const select = await this.tokenRepository.selectWithContext(undefined, ctx);\n    const tokens = await select.execute();\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.clientIdentity.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(ctx: Context) {\n    const select = await this.tokenRepository.selectWithContext(undefined, ctx);\n    const tokens = await select.execute();\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} ctx 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(ctx: Context, amount: number): Promise<void> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const logger = this.logFor(ctx).for(this.Mint);\n\n    // Get ID of submitting client identity\n    const minter = ctx.clientIdentity.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(ctx),\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      logger,\n      \"\",\n      ERC20Events.TRANSFER,\n      \"\",\n      ctx,\n      \"\",\n      transferEvent\n    );\n  }\n\n  /**\n   * Burn redeem tokens from minter's account balance\n   *\n   * @param {Context} ctx 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(ctx: Context, amount: number): Promise<void> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const logger = this.logFor(ctx).for(this.Burn);\n\n    const minter = ctx.clientIdentity.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    logger.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      logger,\n      \"\",\n      ERC20Events.TRANSFER,\n      \"\",\n      ctx,\n      \"\",\n      transferEvent\n    );\n  }\n\n  /**\n   * BurnFrom redeem tokens from account allowence and balance\n   *\n   * @param {Context} ctx 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(ctx: Context, account: string, amount: number): Promise<void> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    const logger = this.logFor(ctx).for(this.BurnFrom);\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    logger.info(`${amount} tokens were berned 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      logger,\n      \"\",\n      ERC20Events.TRANSFER,\n      \"\",\n      ctx,\n      \"\",\n      transferEvent\n    );\n  }\n\n  /**\n   * ClientAccountBalance returns the balance of the requesting client's account.\n   *\n   * @param {Context} ctx the transaction context\n   * @returns {Number} Returns the account balance\n   */\n  @Transaction()\n  async ClientAccountBalance(ctx: Context): Promise<number> {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    // Get ID of submitting client identity\n    const clientAccountID = ctx.clientIdentity.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()\n  async ClientAccountID(ctx: Context) {\n    // Check contract options are already set first to execute the function\n    await this.CheckInitialized(ctx);\n\n    // Get ID of submitting client identity\n    const clientAccountID = ctx.clientIdentity.getID();\n    return clientAccountID;\n  }\n}\n"]}