@payburner/keyburner-sidewinder-core/dist/npm/services/Api.js

Core library for Keyburner Sidewinder

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Api = void 0;
const npm_1 = require("@payburner/keyburner-core/dist/npm");
const npm_2 = require("@payburner/keyburner-sidewinder-model/dist/npm");
class Api {
    constructor() {
        this.keyburner = null;
        this.keyPair = null;
        this.accountId = null;
        this.tokenService = null;
        this.keyburner = new npm_1.KeyBurner();
    }
    newAccount() {
        const seed = this.keyburner.generateSeed();
        this.keyPair = this.keyburner.deriveKeyPair(seed);
        this.accountId = this.keyburner.deriveAddress(this.keyPair);
    }
    initAccount(seed) {
        this.keyPair = this.keyburner.deriveKeyPair(seed);
        this.accountId = this.keyburner.deriveAddress(this.keyPair);
    }
    signTokenCreateRequest(createTokenRequest) {
        createTokenRequest['sequence'] = 1;
        return this.keyburner.signTransaction(createTokenRequest, this.keyPair);
    }
    decodeTransaction(signedTransaction) {
        return this.keyburner.decodeTransaction(signedTransaction);
    }
    getTransactionType(decodedTransaction) {
        return decodedTransaction.payload.transaction_type;
    }
    processTransaction(signedTransaction) {
        const self = this;
        return new Promise((resolve, reject) => {
            const decodedTransaction = this.decodeTransaction(signedTransaction);
            if (decodedTransaction.verified) {
                const transactionType = this.getTransactionType(decodedTransaction);
                switch (transactionType) {
                    case npm_2.TransactionTypes.CreateToken:
                        self.processCreateToken(decodedTransaction)
                            .then((result) => {
                            resolve(result);
                        }).catch((error) => {
                            resolve(error);
                        });
                        break;
                    default:
                        resolve({ status: 400, error: 'Unsupported Transaction' });
                }
            }
            else {
                resolve({ status: 400, error: 'The transaction is invalid' });
            }
        });
    }
    processCreateToken(decodedTransaction) {
        const self = this;
        return new Promise((resolve, reject) => {
            const createTokenTransaction = decodedTransaction.payload;
            self.tokenService.getToken(createTokenTransaction.token_symbol).then((token) => {
                resolve({ status: 400, error: 'A token with that symbol already exists.' });
            }).catch((error) => {
                console.log('The token ' + createTokenTransaction.token_symbol + ' does not exist. Creating.');
                const token = {
                    token_symbol: createTokenTransaction.token_symbol,
                    environment: createTokenTransaction.environment,
                    token_issuer_account_id: decodedTransaction.accountId,
                    initial_amount: createTokenTransaction.initial_amount,
                    transaction_fee: createTokenTransaction.transaction_fee,
                    allow_transfers_between_accounts: createTokenTransaction.allow_transfers_between_accounts,
                    is_permissioned: createTokenTransaction.is_permissioned,
                    maximum_balance: createTokenTransaction.maximum_balance,
                    minimum_transfer_amount: createTokenTransaction.minimum_transfer_amount,
                    maximum_transfer_amount: createTokenTransaction.maximum_transfer_amount,
                    frozen: createTokenTransaction.frozen,
                    decimal_precision: createTokenTransaction.decimal_precision,
                    underlying_currency: createTokenTransaction.underlying_currency,
                    underlying_account_id: createTokenTransaction.underlying_account_id,
                    underlying_currency_ratio: createTokenTransaction.underlying_currency_ratio
                };
                self.tokenService.createToken(token).then((createResponse) => {
                    resolve({ status: 200, data: createResponse });
                }).catch((error) => {
                    resolve({ status: 500, error });
                });
            });
        });
    }
}
exports.Api = Api;
//# sourceMappingURL=Api.js.map