@payburner/keyburner-sidewinder-core/dist/npm/services/impl/memory/MemoryTokenService.js

Core library for Keyburner Sidewinder

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MemoryTokenService = void 0;
const npm_1 = require("@payburner/keyburner-sidewinder-model/dist/npm");
class MemoryTokenService {
    constructor() {
        this.tokens = {};
        this.accounts = {};
    }
    tokenId(environment, token_symbol) {
        return environment + '/' + token_symbol;
    }
    createToken(token) {
        const self = this;
        return new Promise((resolve, reject) => {
            if (typeof self.tokens[self.tokenId(token.environment, token.token_symbol)] === 'undefined') {
                self.tokens[self.tokenId(token.environment, token.token_symbol)] = token;
                resolve(token);
            }
            else {
                reject('Token already exists.');
            }
        });
    }
    getToken(environment, token_symbol) {
        const self = this;
        return new Promise((resolve, reject) => {
            if (typeof self.tokens[self.tokenId(environment, token_symbol)] === 'undefined') {
                reject('Token not found.');
            }
            else {
                const token = JSON.parse(JSON.stringify(this.tokens[self.tokenId(environment, token_symbol)]));
                resolve(token);
            }
        });
    }
    getTokenAccount(environment, token_symbol, address) {
        const self = this;
        return new Promise((resolve, reject) => {
            const account = self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)];
            if (typeof account === 'undefined') {
                resolve(null);
            }
            else {
                resolve(JSON.parse(JSON.stringify(account)));
            }
        });
    }
    isAddressPermissionedOnToken(environment, token_symbol, address) {
        return new Promise((resolve) => {
            resolve(false);
        });
    }
    createTokenAccount(token_account) {
        const self = this;
        const environment = token_account.environment;
        const address = token_account.account_owner_address;
        const token_symbol = token_account.token_symbol;
        return new Promise((resolve, reject) => {
            if (typeof self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)] !== 'undefined') {
                reject('Account already exists.');
            }
            else {
                self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)] = token_account;
                resolve(token_account);
            }
        });
    }
    setAmounts(environment, address, token_symbol, total_balance, available_balance) {
        console.log('SET AMOUNTS:' + npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address) + ' ' + total_balance + ' ' + available_balance);
        const self = this;
        return new Promise((resolve, reject) => {
            if (typeof self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)] === 'undefined') {
                reject('Account not found');
            }
            else {
                self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)].available_balance = available_balance;
                self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)].total_balance = total_balance;
                resolve(true);
            }
        });
    }
    updateToken(token) {
        const self = this;
        const environment = token.environment;
        const token_symbol = token.token_symbol;
        return new Promise((resolve, reject) => {
            if (typeof self.tokens[self.tokenId(environment, token_symbol)] === 'undefined') {
                reject('Token not found.');
            }
            else {
                this.tokens[self.tokenId(environment, token_symbol)] = token;
                resolve(this.tokens[self.tokenId(environment, token_symbol)]);
            }
        });
    }
    freezeTokenAccount(environment, token_symbol, address) {
        const self = this;
        return new Promise((resolve, reject) => {
            if (typeof self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)] === 'undefined') {
                reject('Account not found');
            }
            else {
                self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)].frozen = true;
                resolve(self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)]);
            }
        });
    }
    unFreezeTokenAccount(environment, token_symbol, address) {
        const self = this;
        return new Promise((resolve, reject) => {
            if (typeof self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)] === 'undefined') {
                reject('Account not found');
            }
            else {
                self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)].frozen = false;
                resolve(self.accounts[npm_1.AccountUtils.calculateTokenAccountId(environment, token_symbol, address)]);
            }
        });
    }
}
exports.MemoryTokenService = MemoryTokenService;
//# sourceMappingURL=MemoryTokenService.js.map