test-ic-wallet-middleware-icrc/dist/handlers/assetHandlers/getListAssetHandler/getListAssetHandler.js

Ic middleware wallet ICRC protocol

"use strict";
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);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetListAssetHandler = void 0;
const common_1 = require("@ic-wallet-middleware/common");
const loadAssetHandler_1 = require("../../../internalHandlers/loadAssetHandler/loadAssetHandler");
const assetRepository_1 = require("../../../repositories/persists/assetRepository/assetRepository");
const types_1 = require("../../../types");
const assetManagerConfiguration_1 = require("../../../types/configuration/assetManagerConfiguration");
const typedi_1 = require("typedi");
let GetListAssetHandler = class GetListAssetHandler extends common_1.BaseHandler {
    configuration;
    assetRepository;
    loadAssetHandler;
    constructor(logger, configuration, assetRepository, loadAssetHandler) {
        super(logger);
        this.configuration = configuration;
        this.assetRepository = assetRepository;
        this.loadAssetHandler = loadAssetHandler;
    }
    validate(form) {
        return Promise.resolve();
    }
    async process(form) {
        const result = {
            assets: [],
        };
        const assetList = await this.assetRepository.getTokensOrDefault();
        const handlers = [];
        assetList.forEach((walletAsset) => {
            const info = {
                ledgerAddress: walletAsset.ledgerAddress,
                indexAddress: walletAsset.indexAddress,
                subAccounts: walletAsset.subAccounts.map((sa) => types_1.SubAccountId.parseFromString(sa.subAccountId)),
                loadType: form.loadType,
            };
            handlers.push(this.loadAssetHandler.handle(info));
        });
        const handlersResult = await Promise.all(handlers);
        for (let asset of assetList) {
            const assetView = {
                ledgerAddress: asset.ledgerAddress,
                indexAddress: asset.indexAddress,
                name: asset.name,
                tokenName: asset.tokenName,
                sortOrder: asset.sortOrder,
                decimal: 0,
                logo: asset.logo,
                subAccounts: asset.subAccounts.map((sa) => {
                    return {
                        ledgerAddress: sa.ledgerAddress,
                        name: sa.name,
                        balance: BigInt(0),
                        currencyAmount: "",
                        decimal: 0,
                        subAccountId: types_1.SubAccountId.parseFromString(sa.subAccountId),
                        isSync: false,
                    };
                }),
                symbol: asset.symbol,
                tokenSymbol: asset.tokenSymbol,
                shortDecimal: asset.shortDecimal,
                transactionFee: BigInt(0),
                supportedStandards: asset.supportedStandards,
                isSync: false,
            };
            const failedResults = handlersResult.filter((h) => !h.isSuccess);
            if (failedResults.length > 0) {
                const errors = failedResults.flatMap((x) => x.errors);
                throw errors;
            }
            const loadAsset = handlersResult.find((h) => h.isSuccess && h.data?.ledgerAddress == asset.ledgerAddress);
            if (loadAsset) {
                assetView.transactionFee = loadAsset.data.transactionFee;
                assetView.decimal = loadAsset.data.decimal;
                assetView.isSync = true;
                for (let loadSubAccount of loadAsset.data.subAccounts) {
                    const subAccount = assetView.subAccounts.find((x) => x.subAccountId.equals(loadSubAccount.subAccountId));
                    if (subAccount) {
                        subAccount.balance = loadSubAccount.balance;
                        subAccount.currencyAmount = loadSubAccount.currencyAmount;
                        subAccount.decimal = loadAsset.data.decimal;
                        subAccount.isSync = true;
                    }
                    else {
                        loadSubAccount.name = "-";
                        loadSubAccount.decimal = loadAsset.data.decimal;
                        loadSubAccount.isSync = true;
                        assetView.subAccounts.push(loadSubAccount);
                        await this.assetRepository.addSubAccount({
                            ledgerAddress: loadSubAccount.ledgerAddress,
                            subAccountId: loadSubAccount.subAccountId.toString(),
                            name: loadSubAccount.name
                        });
                    }
                }
                ;
            }
            result.assets.push(assetView);
        }
        ;
        return result;
    }
};
exports.GetListAssetHandler = GetListAssetHandler;
exports.GetListAssetHandler = GetListAssetHandler = __decorate([
    (0, typedi_1.Service)(),
    __param(0, (0, typedi_1.Inject)("ILogger")),
    __param(1, (0, typedi_1.Inject)("AssetManagerConfiguration")),
    __param(2, (0, typedi_1.Inject)("AssetRepository")),
    __metadata("design:paramtypes", [Object, assetManagerConfiguration_1.AssetManagerConfiguration,
        assetRepository_1.AssetRepository,
        loadAssetHandler_1.LoadAssetHandler])
], GetListAssetHandler);