@ic-wallet-kit/hpl/dist/handlers/virtualAccounts/checkLinkCodeHandler/checkLinkCodeHandler.js

Ic middleware wallet HPL 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.CheckLinkCodeHandler = void 0;
const hplWrappers_1 = require("../../../hplWrappers");
const repositories_1 = require("../../../repositories");
const service_1 = require("../../../service");
const common_1 = require("@ic-wallet-kit/common");
require("reflect-metadata");
const typedi_1 = require("typedi");
let CheckLinkCodeHandler = class CheckLinkCodeHandler extends common_1.BaseHandler {
    identifierService;
    canisterService;
    hplAssetRepository;
    constructor(logger, identifierService, canisterService, hplAssetRepository) {
        super(logger);
        this.identifierService = identifierService;
        this.canisterService = canisterService;
        this.hplAssetRepository = hplAssetRepository;
    }
    validate(form) {
        if (!form.linkCode) {
            throw new common_1.ValidationError("check.code.linkCode.is.required", (0, common_1.getPropertyName)(form, f => f.linkCode), "Field linkCode is required");
        }
        return Promise.resolve();
    }
    async process(form) {
        const result = {
            remoteInfo: undefined,
            owner: undefined,
            error: ""
        };
        let ownerInfo;
        try {
            const code = form.linkCode;
            if (code.length > 2) {
                const size = Number(`0x${code[0]}`) + 1;
                const princCode = BigInt(`0x${code.slice(1, code.length - size)}`);
                ownerInfo = { ownerId: princCode, linkId: BigInt(`0x${code.slice(-size)}`) };
            }
        }
        catch (error) {
            this.logger.logError(error);
            result.error = error.message;
            return result;
        }
        if (!ownerInfo) {
            result.error = "Invalid code";
            return result;
        }
        const ownersActorWrapper = hplWrappers_1.OwnersActorWrapper.create(this.identifierService.getAgent(), this.canisterService.getOwnerCanisterId());
        let ownerPrincipal;
        try {
            ownerPrincipal = await ownersActorWrapper.get(ownerInfo.ownerId);
        }
        catch (e) {
            result.error = "Invalid ownerId";
            return result;
        }
        const ingressActorWrapper = hplWrappers_1.IngressActorWrapper.create(this.identifierService.getAgent(), this.canisterService.getLedgerCanisterId(), this.logger);
        const remoteAccountInfoResult = await ingressActorWrapper.remoteAccountInfo({
            id: [ownerPrincipal, ownerInfo.linkId]
        });
        const remoteAccountInfo = remoteAccountInfoResult
            .map((r) => {
            return {
                remoteId: r[0][0],
                accountId: r[0][1],
                remoteInfo: r[1]
            };
        })
            .find((r) => r.accountId === ownerInfo.linkId);
        if (!remoteAccountInfo) {
            result.error = "RemoteInfo not found";
            return result;
        }
        const remoteAccountStateResult = await ingressActorWrapper.getState(BigInt(0), BigInt(0), BigInt(0), [{
                id: [ownerPrincipal, ownerInfo.linkId]
            }]);
        const remoteState = remoteAccountStateResult.remoteAccounts.find((r) => r.remoteAccountId === remoteAccountInfo.accountId);
        if (!remoteState) {
            result.error = "RemoteState not found";
            return result;
        }
        const asset = await this.hplAssetRepository.getAssetById(remoteAccountInfo.remoteInfo.ft.toString());
        result.remoteInfo = {
            name: "",
            remoteAccountId: remoteAccountInfo.accountId.toString(),
            expired: Number(remoteState.time),
            amount: remoteState.accountState.ft.toString(),
            assetId: remoteAccountInfo.remoteInfo.ft.toString(),
            assetName: asset.name
                ? asset.name
                : asset.assetName,
            assetSymbol: asset.symbol
                ? asset.symbol
                : asset.assetSymbol,
            assetLogo: asset.logo,
            code: form.linkCode,
        };
        result.owner = ownerPrincipal;
        return result;
    }
};
exports.CheckLinkCodeHandler = CheckLinkCodeHandler;
exports.CheckLinkCodeHandler = CheckLinkCodeHandler = __decorate([
    (0, typedi_1.Service)(),
    __param(0, (0, typedi_1.Inject)("ILogger")),
    __param(3, (0, typedi_1.Inject)("HplAssetRepository")),
    __metadata("design:paramtypes", [Object, common_1.IdentifierService,
        service_1.CanisterService,
        repositories_1.HplAssetRepository])
], CheckLinkCodeHandler);