@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/crud/serialized-crud-contract.js

@@ -0,0 +1,168 @@
+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 { FabricCrudContract } from "./crud-contract.js";
+import { Context as Ctx, Transaction } from "fabric-contract-api";
+import { Logging } from "@decaf-ts/logging";
+/**
+ * @description CRUD contract variant that serializes/deserializes payloads
+ * @summary Exposes the same CRUD operations as FabricCrudContract but takes and returns JSON strings to facilitate simple client interactions.
+ * @template M - Model type handled by this contract
+ * @param {string} name - The contract name
+ * @param {Constructor<M>} clazz - The model constructor used to instantiate models from JSON
+ * @return {void}
+ * @class SerializedCrudContract
+ * @example
+ * const contract = new SerializedCrudContract<MyModel>('MyModelContract', MyModel);
+ * // Client submits JSON string payloads and receives JSON string responses
+ */
+export class SerializedCrudContract extends FabricCrudContract {
+    constructor(name, clazz) {
+        super(name, clazz);
+    }
+    /**
+     * @description Creates a logger for a specific chaincode context
+     * @summary Returns a ContractLogger instance configured for the current context
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @return {ContractLogger} The logger instance
+     */
+    logFor(ctx) {
+        return Logging.for(SerializedCrudContract, {}, ctx);
+    }
+    async create(ctx, model) {
+        const log = this.logFor(ctx).for(this.create);
+        log.info(`Creating model: ${model}`);
+        const m = this.deserialize(model);
+        log.info(`Model deserialized: ${JSON.stringify(m)}`);
+        return this.serialize((await super.create(ctx, m)));
+    }
+    async read(ctx, key) {
+        const log = this.logFor(ctx).for(this.read);
+        log.info(`Reading id: ${key}`);
+        return this.serialize((await super.read(ctx, key)));
+    }
+    async update(ctx, model) {
+        const log = this.logFor(ctx).for(this.update);
+        log.info(`Updating model: ${model}`);
+        return this.serialize((await super.update(ctx, model)));
+    }
+    async delete(ctx, key) {
+        const log = this.logFor(ctx).for(this.delete);
+        log.info(`Deleting id: ${key}`);
+        return this.serialize((await super.delete(ctx, key)));
+    }
+    async deleteAll(ctx, keys) {
+        const parsedKeys = JSON.parse(keys);
+        const log = this.logFor(ctx).for(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(ctx, keys) {
+        const parsedKeys = JSON.parse(keys);
+        const log = this.logFor(ctx).for(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(ctx, models) {
+        const log = this.logFor(ctx).for(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 raw(ctx, rawInput, docsOnly) {
+        const parsedInput = JSON.parse(rawInput);
+        return super.raw(ctx, parsedInput, docsOnly);
+    }
+    async init(ctx) {
+        await super.init(ctx);
+    }
+    async healthcheck(ctx) {
+        //TODO: TRIM NOT WORKING CHECK LATER
+        return JSON.stringify(await super.healthcheck(ctx));
+    }
+    async createAll(ctx, models) {
+        const log = this.logFor(ctx).for(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`);
+        return JSON.stringify((await super.createAll(ctx, modelList)).map((m) => this.serialize(m)));
+    }
+}
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "create", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "read", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "update", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "delete", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "deleteAll", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "readAll", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "updateAll", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String, Boolean]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "raw", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "init", null);
+__decorate([
+    Transaction(false),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "healthcheck", null);
+__decorate([
+    Transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Ctx, String]),
+    __metadata("design:returntype", Promise)
+], SerializedCrudContract.prototype, "createAll", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialized-crud-contract.js","sourceRoot":"","sources":["../../../../src/contracts/crud/serialized-crud-contract.ts"],"names":[],"mappings":"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","sourcesContent":["import { FabricCrudContract } from \"./crud-contract\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { Context, Context as Ctx, Transaction } from \"fabric-contract-api\";\nimport { ContractLogger } from \"../logging\";\nimport { Logging } from \"@decaf-ts/logging\";\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  /**\n   * @description Creates a logger for a specific chaincode context\n   * @summary Returns a ContractLogger instance configured for the current context\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @return {ContractLogger} The logger instance\n   */\n  public override logFor(ctx: Context): ContractLogger {\n    return Logging.for(SerializedCrudContract, {}, ctx) as ContractLogger;\n  }\n\n  @Transaction()\n  override async create(ctx: Ctx, model: string): Promise<string> {\n    const log = this.logFor(ctx).for(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    return this.serialize((await super.create(ctx, m)) as M);\n  }\n\n  @Transaction(false)\n  override async read(ctx: Ctx, key: string): Promise<string> {\n    const log = this.logFor(ctx).for(this.read);\n    log.info(`Reading id: ${key}`);\n    return this.serialize((await super.read(ctx, key)) as M);\n  }\n\n  @Transaction()\n  override async update(ctx: Ctx, model: string): Promise<string> {\n    const log = this.logFor(ctx).for(this.update);\n    log.info(`Updating model: ${model}`);\n    return this.serialize((await super.update(ctx, model)) as M);\n  }\n\n  @Transaction()\n  override async delete(ctx: Ctx, key: string): Promise<string> {\n    const log = this.logFor(ctx).for(this.delete);\n    log.info(`Deleting id: ${key}`);\n    return this.serialize((await super.delete(ctx, key)) as M);\n  }\n\n  @Transaction()\n  override async deleteAll(ctx: Ctx, keys: string): Promise<string> {\n    const parsedKeys: string[] = JSON.parse(keys);\n    const log = this.logFor(ctx).for(this.deleteAll);\n\n    log.info(`deleting ${parsedKeys.length} entries from the table`);\n\n    return JSON.stringify(\n      ((await super.deleteAll(ctx, parsedKeys)) as M[]).map(\n        (m) => this.serialize(m) as string\n      )\n    );\n  }\n\n  @Transaction(false)\n  override async readAll(ctx: Ctx, keys: string): Promise<string> {\n    const parsedKeys: string[] = JSON.parse(keys);\n\n    const log = this.logFor(ctx).for(this.readAll);\n    log.info(`reading ${parsedKeys.length} entries from the table`);\n\n    return JSON.stringify(\n      ((await super.readAll(ctx, parsedKeys)) as M[]).map((m) =>\n        this.serialize(m)\n      )\n    );\n  }\n\n  @Transaction()\n  override async updateAll(ctx: Ctx, models: string): Promise<string> {\n    const log = this.logFor(ctx).for(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, modelList)) as M[]).map(\n        (m) => this.serialize(m) as string\n      )\n    );\n  }\n\n  @Transaction(false)\n  override async raw(\n    ctx: Ctx,\n    rawInput: string,\n    docsOnly: boolean\n  ): Promise<any> {\n    const parsedInput: MangoQuery = JSON.parse(rawInput);\n    return super.raw(ctx, parsedInput, docsOnly);\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(ctx: Ctx): Promise<string> {\n    //TODO: TRIM NOT WORKING CHECK LATER\n    return JSON.stringify(await super.healthcheck(ctx));\n  }\n\n  @Transaction()\n  override async createAll(ctx: Ctx, models: string): Promise<string> {\n    const log = this.logFor(ctx).for(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    return JSON.stringify(\n      ((await super.createAll(ctx, modelList)) as M[]).map(\n        (m) => this.serialize(m) as string\n      )\n    );\n  }\n}\n"]}

package/lib/esm/contracts/erc20/erc20contract.d.ts

@@ -0,0 +1,151 @@
+import { Context } from "fabric-contract-api";
+import { Allowance, ERC20Token, ERC20Wallet } from "./models";
+import { FabricCrudContract } from "../crud/crud-contract";
+/**
+ * @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 declare abstract class FabricERC20Contract extends FabricCrudContract<ERC20Wallet> {
+    private walletRepository;
+    private tokenRepository;
+    private allowanceRepository;
+    protected constructor(name: string);
+    TokenName(ctx: Context): Promise<string>;
+    /**
+     * Return the symbol of the token. E.g. “HIX”.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {String} Returns the symbol of the token
+     */
+    Symbol(ctx: Context): Promise<string>;
+    /**
+     * 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
+     */
+    Decimals(ctx: Context): Promise<number>;
+    /**
+     * Return the total token supply.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {Number} Returns the total token supply
+     */
+    TotalSupply(ctx: Context): Promise<number>;
+    /**
+     * 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
+     */
+    BalanceOf(ctx: Context, owner: string): Promise<number>;
+    /**
+     * @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
+     */
+    Transfer(ctx: Context, to: string, value: number): Promise<boolean>;
+    /**
+     * 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
+     */
+    TransferFrom(ctx: Context, from: string, to: string, value: number): Promise<boolean>;
+    _transfer(ctx: Context, from: string, to: string, value: number): Promise<boolean>;
+    /**
+     * 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
+     */
+    Approve(ctx: Context, spender: string, value: number): Promise<boolean>;
+    /**
+     * 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
+     */
+    Allowance(ctx: Context, owner: string, spender: string): Promise<number>;
+    _getAllowance(ctx: Context, owner: string, spender: string): Promise<Allowance>;
+    /**
+     * 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
+     */
+    Initialize(ctx: Context, token: ERC20Token): Promise<boolean>;
+    CheckInitialized(ctx: Context): Promise<void>;
+    /**
+     * 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
+     */
+    Mint(ctx: Context, amount: number): Promise<void>;
+    /**
+     * 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
+     */
+    Burn(ctx: Context, amount: number): Promise<void>;
+    /**
+     * 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
+     */
+    BurnFrom(ctx: Context, account: string, amount: number): Promise<void>;
+    /**
+     * ClientAccountBalance returns the balance of the requesting client's account.
+     *
+     * @param {Context} ctx the transaction context
+     * @returns {Number} Returns the account balance
+     */
+    ClientAccountBalance(ctx: Context): Promise<number>;
+    ClientAccountID(ctx: Context): Promise<string>;
+}