hive-keychain-commons 1.1.0

package/README.md

@@ -0,0 +1,2 @@
+# hive-keychain-commons
+Platform agnostic functions used in Hive Keychain mobile and extensions

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces/keychain';
+export { LeaseKeys } from './lease-market/lease-keys';
+export { AcceptRequestJSON, CancelDelegationJSON, CancelRequestJSON, PaymentJSON, ReimbursmentJSON, RequestCancelRequestJSON, RequestJSON, } from './lease-market/lease-market.interface';
+export * from './swaps/config.interface';
+export * from './swaps/swap-api.interface';
+export * from './swaps/swap.interface';

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaseKeys = void 0;
+__exportStar(require("./interfaces/keychain"), exports);
+var lease_keys_1 = require("./lease-market/lease-keys");
+Object.defineProperty(exports, "LeaseKeys", { enumerable: true, get: function () { return lease_keys_1.LeaseKeys; } });
+__exportStar(require("./swaps/config.interface"), exports);
+__exportStar(require("./swaps/swap-api.interface"), exports);
+__exportStar(require("./swaps/swap.interface"), exports);

package/lib/interfaces/keychain.d.ts

@@ -0,0 +1,278 @@
+import { Operation, Transaction } from '@hiveio/dhive';
+export declare enum KeychainRequestTypes {
+    decode = "decode",
+    encode = "encode",
+    signBuffer = "signBuffer",
+    broadcast = "broadcast",
+    addAccountAuthority = "addAccountAuthority",
+    removeAccountAuthority = "removeAccountAuthority",
+    removeKeyAuthority = "removeKeyAuthority",
+    addKeyAuthority = "addKeyAuthority",
+    signTx = "signTx",
+    post = "post",
+    vote = "vote",
+    custom = "custom",
+    signedCall = "signedCall",
+    transfer = "transfer",
+    sendToken = "sendToken",
+    delegation = "delegation",
+    witnessVote = "witnessVote",
+    proxy = "proxy",
+    powerUp = "powerUp",
+    powerDown = "powerDown",
+    createClaimedAccount = "createClaimedAccount",
+    createProposal = "createProposal",
+    removeProposal = "removeProposal",
+    updateProposalVote = "updateProposalVote",
+    addAccount = "addAccount",
+    convert = "convert",
+    recurrentTransfer = "recurrentTransfer"
+}
+export declare enum KeychainKeyTypes {
+    posting = "Posting",
+    active = "Active",
+    memo = "Memo"
+}
+export declare enum KeychainKeyTypesLC {
+    posting = "posting",
+    active = "active",
+    memo = "memo"
+}
+declare type CommonRequestParams = {
+    rpc?: string;
+    domain: string;
+    key?: string;
+};
+export declare type RequestDecode = CommonRequestParams & {
+    type: KeychainRequestTypes.decode;
+    username: string;
+    message: string;
+    method: KeychainKeyTypes;
+};
+export declare type RequestEncode = CommonRequestParams & {
+    type: KeychainRequestTypes.encode;
+    username: string;
+    receiver: string;
+    message: string;
+    method: KeychainKeyTypes;
+};
+export declare type ExcludeCommonParams<T> = Omit<T, 'rpc' | 'type' | 'key' | 'domain'>;
+export declare type RequestSignBuffer = CommonRequestParams & {
+    type: KeychainRequestTypes.signBuffer;
+    username?: string;
+    message: string;
+    method: KeychainKeyTypes;
+    title?: string;
+};
+export declare type RequestBroadcast = CommonRequestParams & {
+    type: KeychainRequestTypes.broadcast;
+    username: string;
+    operations: string | Operation[];
+    method: KeychainKeyTypes;
+};
+export declare type RequestAddAccountAuthority = CommonRequestParams & {
+    type: KeychainRequestTypes.addAccountAuthority;
+    authorizedUsername: string;
+    role: KeychainKeyTypes;
+    weight: number;
+    username: string;
+};
+export declare type RequestRemoveAccountAuthority = CommonRequestParams & {
+    type: KeychainRequestTypes.removeAccountAuthority;
+    authorizedUsername: string;
+    role: KeychainKeyTypes;
+    username: string;
+};
+export declare type RequestAddKeyAuthority = CommonRequestParams & {
+    type: KeychainRequestTypes.addKeyAuthority;
+    authorizedKey: string;
+    role: KeychainKeyTypes;
+    username: string;
+    weight: number;
+};
+export declare type RequestRemoveKeyAuthority = CommonRequestParams & {
+    type: KeychainRequestTypes.removeKeyAuthority;
+    authorizedKey: string;
+    role: KeychainKeyTypes;
+    username: string;
+};
+export declare type RequestSignTx = CommonRequestParams & {
+    type: KeychainRequestTypes.signTx;
+    username: string;
+    tx: Transaction;
+    method: KeychainKeyTypes;
+};
+export declare type RequestPost = CommonRequestParams & {
+    type: KeychainRequestTypes.post;
+    username: string;
+    title?: string;
+    body: string;
+    parent_perm: string;
+    parent_username?: string;
+    json_metadata: string;
+    permlink: string;
+    comment_options: string;
+};
+export declare type RequestVote = CommonRequestParams & {
+    type: KeychainRequestTypes.vote;
+    username: string;
+    permlink: string;
+    author: string;
+    weight: string | number;
+};
+export declare type RequestCustomJSON = CommonRequestParams & {
+    type: KeychainRequestTypes.custom;
+    username?: string;
+    id: string;
+    method: KeychainKeyTypes;
+    json: string;
+    display_msg: string;
+};
+export declare type RequestSignedCall = CommonRequestParams & {
+    type: KeychainRequestTypes.signedCall;
+    username: string;
+    method: string;
+    params: string;
+    typeWif: KeychainKeyTypes;
+};
+export declare type RequestTransfer = CommonRequestParams & {
+    type: KeychainRequestTypes.transfer;
+    username?: string;
+    to: string;
+    amount: string;
+    memo: string;
+    enforce: boolean;
+    currency: string;
+};
+export declare type RequestSendToken = CommonRequestParams & {
+    type: KeychainRequestTypes.sendToken;
+    username: string;
+    to: string;
+    amount: string;
+    memo: string;
+    currency: string;
+};
+export declare type RequestDelegation = CommonRequestParams & {
+    type: KeychainRequestTypes.delegation;
+    username?: string;
+    delegatee: string;
+    amount: string;
+    unit: string;
+};
+export declare type RequestWitnessVote = CommonRequestParams & {
+    type: KeychainRequestTypes.witnessVote;
+    username?: string;
+    witness: string;
+    vote: boolean;
+};
+export declare type RequestProxy = CommonRequestParams & {
+    type: KeychainRequestTypes.proxy;
+    username?: string;
+    proxy: string;
+};
+export declare type RequestPowerUp = CommonRequestParams & {
+    type: KeychainRequestTypes.powerUp;
+    username: string;
+    recipient: string;
+    hive: string;
+};
+export declare type RequestPowerDown = CommonRequestParams & {
+    type: KeychainRequestTypes.powerDown;
+    username: string;
+    hive_power: string;
+};
+export declare type RequestCreateClaimedAccount = CommonRequestParams & {
+    type: KeychainRequestTypes.createClaimedAccount;
+    username: string;
+    new_account: string;
+    owner: string;
+    active: string;
+    posting: string;
+    memo: string;
+};
+export declare type RequestUpdateProposalVote = CommonRequestParams & {
+    type: KeychainRequestTypes.updateProposalVote;
+    username: string;
+    proposal_ids: string | number[];
+    approve: boolean;
+    extensions: string | any[];
+};
+export declare type RequestCreateProposal = CommonRequestParams & {
+    type: KeychainRequestTypes.createProposal;
+    username: string;
+    receiver: string;
+    subject: string;
+    permlink: string;
+    start: string;
+    end: string;
+    daily_pay: string;
+    extensions: string;
+};
+export declare type RequestRemoveProposal = CommonRequestParams & {
+    type: KeychainRequestTypes.removeProposal;
+    username: string;
+    proposal_ids: string | number[];
+    extensions: string;
+};
+export declare type RequestAddAccountKeys = {
+    posting?: string;
+    active?: string;
+    memo?: string;
+};
+export declare type RequestAddAccount = CommonRequestParams & {
+    type: KeychainRequestTypes.addAccount;
+    username: string;
+    keys: RequestAddAccountKeys;
+};
+export declare type RequestConvert = CommonRequestParams & {
+    type: KeychainRequestTypes.convert;
+    username: string;
+    amount: string;
+    collaterized: boolean;
+};
+export declare type RequestRecurrentTransfer = CommonRequestParams & {
+    type: KeychainRequestTypes.recurrentTransfer;
+    username?: string;
+    to: string;
+    amount: string;
+    currency: string;
+    memo: string;
+    recurrence: number;
+    executions: number;
+};
+export declare type KeychainRequestData = (RequestDecode | RequestEncode | RequestSignBuffer | RequestBroadcast | RequestAddAccountAuthority | RequestRemoveAccountAuthority | RequestAddKeyAuthority | RequestRemoveKeyAuthority | RequestSignTx | RequestPost | RequestVote | RequestCustomJSON | RequestSignedCall | RequestTransfer | RequestSendToken | RequestDelegation | RequestWitnessVote | RequestProxy | RequestPowerUp | RequestPowerDown | RequestCreateClaimedAccount | RequestUpdateProposalVote | RequestCreateProposal | RequestRemoveProposal | RequestAddAccount | RequestConvert | RequestRecurrentTransfer) & {
+    redirect_uri?: string;
+};
+export declare type RequestId = {
+    request_id: number;
+};
+export declare type KeychainRequest = KeychainRequestData & RequestId;
+export declare type HiveErrorMessage = {
+    message: string;
+    code: number;
+    data?: any;
+};
+export declare type RequestSuccess = {
+    data: KeychainRequestData;
+    request_id: number;
+    result: any;
+    message: string;
+};
+export declare type RequestError = {
+    data: KeychainRequestData;
+    request_id: number;
+    error: any;
+    message: string;
+};
+export declare type RequestResponse = {
+    success: boolean;
+    error: any | null;
+    result: any | null;
+} & (RequestSuccess | RequestError);
+export declare type KeychainRequestWrapper = {
+    command: string;
+    domain: string;
+    request: KeychainRequest;
+    request_id: number;
+};
+export {};

package/lib/interfaces/keychain.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeychainKeyTypesLC = exports.KeychainKeyTypes = exports.KeychainRequestTypes = void 0;
+var KeychainRequestTypes;
+(function (KeychainRequestTypes) {
+    KeychainRequestTypes["decode"] = "decode";
+    KeychainRequestTypes["encode"] = "encode";
+    KeychainRequestTypes["signBuffer"] = "signBuffer";
+    KeychainRequestTypes["broadcast"] = "broadcast";
+    KeychainRequestTypes["addAccountAuthority"] = "addAccountAuthority";
+    KeychainRequestTypes["removeAccountAuthority"] = "removeAccountAuthority";
+    KeychainRequestTypes["removeKeyAuthority"] = "removeKeyAuthority";
+    KeychainRequestTypes["addKeyAuthority"] = "addKeyAuthority";
+    KeychainRequestTypes["signTx"] = "signTx";
+    KeychainRequestTypes["post"] = "post";
+    KeychainRequestTypes["vote"] = "vote";
+    KeychainRequestTypes["custom"] = "custom";
+    KeychainRequestTypes["signedCall"] = "signedCall";
+    KeychainRequestTypes["transfer"] = "transfer";
+    KeychainRequestTypes["sendToken"] = "sendToken";
+    KeychainRequestTypes["delegation"] = "delegation";
+    KeychainRequestTypes["witnessVote"] = "witnessVote";
+    KeychainRequestTypes["proxy"] = "proxy";
+    KeychainRequestTypes["powerUp"] = "powerUp";
+    KeychainRequestTypes["powerDown"] = "powerDown";
+    KeychainRequestTypes["createClaimedAccount"] = "createClaimedAccount";
+    KeychainRequestTypes["createProposal"] = "createProposal";
+    KeychainRequestTypes["removeProposal"] = "removeProposal";
+    KeychainRequestTypes["updateProposalVote"] = "updateProposalVote";
+    KeychainRequestTypes["addAccount"] = "addAccount";
+    KeychainRequestTypes["convert"] = "convert";
+    KeychainRequestTypes["recurrentTransfer"] = "recurrentTransfer";
+})(KeychainRequestTypes = exports.KeychainRequestTypes || (exports.KeychainRequestTypes = {}));
+var KeychainKeyTypes;
+(function (KeychainKeyTypes) {
+    KeychainKeyTypes["posting"] = "Posting";
+    KeychainKeyTypes["active"] = "Active";
+    KeychainKeyTypes["memo"] = "Memo";
+})(KeychainKeyTypes = exports.KeychainKeyTypes || (exports.KeychainKeyTypes = {}));
+var KeychainKeyTypesLC;
+(function (KeychainKeyTypesLC) {
+    KeychainKeyTypesLC["posting"] = "posting";
+    KeychainKeyTypesLC["active"] = "active";
+    KeychainKeyTypesLC["memo"] = "memo";
+})(KeychainKeyTypesLC = exports.KeychainKeyTypesLC || (exports.KeychainKeyTypesLC = {}));

package/lib/lease-market/lease-keys.d.ts

@@ -0,0 +1,13 @@
+export declare enum LeaseKeys {
+    CANCEL_REQUEST = "kc_lease_cancel_request",
+    REQUEST = "kc_lease_request",
+    ACCEPT_REQUEST = "kc_lease_accept_request",
+    UNDELEGATE = "kc_lease_undelegate_request",
+    FEE_PAYMENT = "kc_lease_fee_payment",
+    PAYOUT_PAYMENT = "kc_lease_payout_payment",
+    REIMBURSMENT_CREATOR_CANCEL = "kc_lease_reimbursment_creator",
+    REIMBURSMENT_DELEGATOR_CANCEL = "kc_lease_reimbursment_del_can",
+    REIMBURSMENT_UNSUFFICIENT_DELEGATION = "kc_lease_reimbursment_del",
+    REIMBURSMENT_DUE_TO_ERROR = "kc_lease_reimbursment_error",
+    CANCEL_DELEGATION = "kc_lease_cancel_delegation"
+}

package/lib/lease-market/lease-keys.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaseKeys = void 0;
+var LeaseKeys;
+(function (LeaseKeys) {
+    LeaseKeys["CANCEL_REQUEST"] = "kc_lease_cancel_request";
+    LeaseKeys["REQUEST"] = "kc_lease_request";
+    LeaseKeys["ACCEPT_REQUEST"] = "kc_lease_accept_request";
+    LeaseKeys["UNDELEGATE"] = "kc_lease_undelegate_request";
+    LeaseKeys["FEE_PAYMENT"] = "kc_lease_fee_payment";
+    LeaseKeys["PAYOUT_PAYMENT"] = "kc_lease_payout_payment";
+    LeaseKeys["REIMBURSMENT_CREATOR_CANCEL"] = "kc_lease_reimbursment_creator";
+    LeaseKeys["REIMBURSMENT_DELEGATOR_CANCEL"] = "kc_lease_reimbursment_del_can";
+    LeaseKeys["REIMBURSMENT_UNSUFFICIENT_DELEGATION"] = "kc_lease_reimbursment_del";
+    LeaseKeys["REIMBURSMENT_DUE_TO_ERROR"] = "kc_lease_reimbursment_error";
+    LeaseKeys["CANCEL_DELEGATION"] = "kc_lease_cancel_delegation";
+})(LeaseKeys = exports.LeaseKeys || (exports.LeaseKeys = {}));

package/lib/lease-market/lease-market.interface.d.ts

@@ -0,0 +1,38 @@
+export interface CancelRequestJSON {
+    leaseId: string;
+}
+export interface CancelDelegationJSON {
+    leaseId: string;
+}
+export interface RequestCancelRequestJSON {
+    leaseId: string;
+}
+export interface AcceptRequestJSON {
+    leaseId: string;
+    token: string;
+}
+export interface RequestJSON {
+    key: string;
+    id: string;
+    delegationValue: number;
+    weeklyPay: string;
+    weeklyPayCurrency: string;
+    duration: string;
+    totalCost: string;
+}
+export interface ReimbursmentJSON {
+    leaseId: string;
+}
+export interface PaymentJSON {
+    paymentNumber: string;
+}
+export interface LeaseLockResponse {
+    success: boolean;
+    message?: string;
+    data?: any;
+}
+export interface LockLeaseData {
+    signedMessage: string;
+    username: string;
+    leaseId: string;
+}

package/lib/lease-market/lease-market.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logger/formats.d.ts

@@ -0,0 +1,5 @@
+import * as winston from 'winston';
+export declare const LoggerFormats: {
+    logFormat: winston.Logform.Format;
+    colorFormat: winston.Logform.Colorizer;
+};

package/lib/logger/formats.js

@@ -0,0 +1,25 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFormats = void 0;
+const moment = require("moment");
+const winston = require("winston");
+const logFormat = winston.format.printf((info) => {
+    const timestamp = moment(info.timestamp);
+    return `[${timestamp.format('L') + ' ' + timestamp.format('HH:mm:ss')}][${info.level}] ${info.message}`;
+});
+const colorFormat = winston.format.colorize({
+    level: true,
+    colors: {
+        INFO: 'blue',
+        ERROR: 'red',
+        OPERATION: 'green',
+        TECHNICAL: 'cyan',
+        DEBUG: 'magenta',
+        WARN: 'yellow',
+    },
+});
+exports.LoggerFormats = {
+    logFormat,
+    colorFormat,
+};

package/lib/logger/logger.d.ts

@@ -0,0 +1,18 @@
+interface LoggerLevel {
+    [level: string]: number;
+}
+export interface LoggerConfig {
+    levels: LoggerLevel;
+    folder?: string;
+    file?: string;
+}
+declare const Logger: {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: any, stacktrace?: Error | undefined) => void;
+    technical: (message: string) => void;
+    operation: (message: string) => void;
+    debug: (message: string) => void;
+    initLogger: (config: LoggerConfig, env: string) => void;
+};
+export default Logger;

package/lib/logger/logger.js

@@ -0,0 +1,57 @@
+"use strict";
+/* eslint-disable */
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+const winston = require("winston");
+const transports_1 = require("./transports");
+let winstonLogger;
+let environment;
+const initLogger = (config, env) => {
+    transports_1.LoggerTransports.initTransport(config);
+    const transports = [transports_1.LoggerTransports.getConsoleTransport()];
+    if (config.file && config.folder) {
+        transports.push(transports_1.LoggerTransports.getFileRotationTransport());
+    }
+    environment = env;
+    winstonLogger = winston.createLogger({
+        levels: config.levels,
+        level: 'DEBUG',
+        transports,
+    });
+};
+const info = (message) => {
+    if (environment === 'TEST')
+        return;
+    winstonLogger.log('INFO', message);
+};
+const debug = (message) => {
+    if (environment === 'TEST')
+        return;
+    if (environment === 'DEBUG') {
+        winstonLogger.log('DEBUG', message);
+    }
+};
+const operation = (message) => {
+    if (environment === 'TEST')
+        return;
+    winstonLogger.log('OPERATION', message);
+};
+const warn = (message) => {
+    if (environment === 'TEST')
+        return;
+    winstonLogger.log('WARN', message);
+};
+const technical = (message) => {
+    if (environment === 'TEST')
+        return;
+    winstonLogger.log('TECHNICAL', message);
+};
+const error = (message, stacktrace) => {
+    if (environment === 'TEST')
+        return;
+    winstonLogger.log('ERROR', `${message}`);
+    if (stacktrace)
+        winstonLogger.log('ERROR', stacktrace.message + '\r\n' + stacktrace.stack);
+};
+const Logger = { info, warn, error, technical, operation, debug, initLogger };
+exports.default = Logger;

package/lib/logger/transports.d.ts

@@ -0,0 +1,7 @@
+import { LoggerConfig } from './logger';
+import DailyRotateFile = require('winston-daily-rotate-file');
+export declare const LoggerTransports: {
+    getConsoleTransport: () => any;
+    getFileRotationTransport: () => DailyRotateFile;
+    initTransport: (config: LoggerConfig) => void;
+};

package/lib/logger/transports.js

@@ -0,0 +1,35 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerTransports = void 0;
+const winston = require("winston");
+const formats_1 = require("./formats");
+const DailyRotateFile = require("winston-daily-rotate-file");
+const path = require("path");
+let fileRotationTransport;
+let consoleTransport;
+const initTransport = (config) => {
+    if (config.file && config.folder) {
+        fileRotationTransport = new DailyRotateFile({
+            filename: path.join(config.folder, config.file),
+            datePattern: 'YYYY-MM-DD',
+            maxSize: '20m',
+            maxFiles: '7',
+            format: winston.format.combine(formats_1.LoggerFormats.logFormat),
+        });
+    }
+    consoleTransport = new winston.transports.Console({
+        format: winston.format.combine(formats_1.LoggerFormats.colorFormat, formats_1.LoggerFormats.logFormat),
+    });
+};
+const getConsoleTransport = () => {
+    return consoleTransport;
+};
+const getFileRotationTransport = () => {
+    return fileRotationTransport;
+};
+exports.LoggerTransports = {
+    getConsoleTransport,
+    getFileRotationTransport,
+    initTransport,
+};

package/lib/plugins/index.d.ts

@@ -0,0 +1,8 @@
+export declare enum PluginMessage {
+    SAVE_PLUGIN_DATA = "SAVE_PLUGIN_DATA",
+    IS_INSTALLED = "IS_INSTALLED",
+    ACK_PLUGIN_INSTALL = "ACK_PLUGIN_INSTALL",
+    GET_PLUGIN_INFO = "GET_PLUGIN_INFO",
+    ACK_PLUGIN_DATA_SAVED = "ACK_PLUGIN_DATA_SAVED",
+    HIVE_KEYCHAIN_RESPONSE = "HIVE_KEYCHAIN_RESPONSE"
+}

package/lib/plugins/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMessage = void 0;
+var PluginMessage;
+(function (PluginMessage) {
+    PluginMessage["SAVE_PLUGIN_DATA"] = "SAVE_PLUGIN_DATA";
+    PluginMessage["IS_INSTALLED"] = "IS_INSTALLED";
+    PluginMessage["ACK_PLUGIN_INSTALL"] = "ACK_PLUGIN_INSTALL";
+    PluginMessage["GET_PLUGIN_INFO"] = "GET_PLUGIN_INFO";
+    PluginMessage["ACK_PLUGIN_DATA_SAVED"] = "ACK_PLUGIN_DATA_SAVED";
+    PluginMessage["HIVE_KEYCHAIN_RESPONSE"] = "HIVE_KEYCHAIN_RESPONSE";
+})(PluginMessage = exports.PluginMessage || (exports.PluginMessage = {}));

package/lib/swaps/config.interface.d.ts

@@ -0,0 +1,61 @@
+import { LoggerConfig } from '../logger/logger';
+import { Provider } from './swap.interface';
+export interface SwapServerConfig {
+    rpc: string[];
+    hiveEngineRpc: string[];
+    logger?: LoggerConfig;
+    swaps: SwapConfig;
+    priceRefreshIntervalInMinutes: number;
+}
+export interface SwapConfig {
+    account: string;
+    marketPool: MarketPoolConfig;
+    blockInfoFilePath: string;
+    fee: SwapFeeConfig;
+    expiration: SwapExpirationConfig;
+    slippage: SwapSlippageConfig;
+    providers: IProviderItem;
+    maxDelayLayerTwo: number;
+    maxDelayLayerTwoWithLayerOne: number;
+}
+export interface SwapExpirationConfig {
+    expiresAfterXDays: number;
+    clearingRoutineFrequencyInHours: number;
+}
+export interface SwapFeeConfig {
+    account: string;
+    amount: number;
+}
+export interface SwapSlippageConfig {
+    min: number;
+    default: number;
+}
+export interface MarketPoolConfig {
+    deactivated?: boolean;
+}
+export interface PublicConfig {
+    account: string;
+    fee: SwapFeeConfig;
+    slippage: SwapSlippageConfig;
+}
+export declare type IProviderItem = {
+    [p in Provider]?: IProvider;
+};
+export interface IProvider {
+    name: Provider;
+    fullName: string;
+    accountName: string;
+    withdrawal: IConvertOptions;
+    deposit: IConvertOptions;
+    deactivated?: boolean;
+    rewardAccountName?: string;
+    rewardToken?: string;
+}
+export interface IConvertOptions {
+    minimumAmount?: number;
+    fee: number;
+    minimumFee: number;
+    balancedFreeFee: boolean;
+    skipBalanceCheck?: boolean;
+    memoRegex?: string;
+}

package/lib/swaps/config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/swaps/swap-api.interface.d.ts

@@ -0,0 +1,14 @@
+export interface SwapApiResponse {
+    result?: SwapApiResult;
+    error?: SwapApiError;
+}
+export declare type SwapApiResult = any;
+export interface SwapApiError {
+    code: number;
+    message: string;
+    reason?: SwapApiErrorReason;
+}
+export interface SwapApiErrorReason {
+    template: string;
+    params?: string[];
+}

package/lib/swaps/swap-api.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/swaps/swap.interface.d.ts

@@ -0,0 +1,86 @@
+export interface EstimateSwapStep {
+    type: SwapStepType;
+    amountStartToken: number;
+    estimate: number;
+    startToken: string;
+    endToken: string;
+    provider: Provider;
+}
+export declare enum SwapStepType {
+    DEPOSIT_TO_HIVE_ENGINE = "DEPOSIT_TO_HIVE_ENGINE",
+    WITHDRAWAL_FROM_HIVE_ENGINE = "WITHDRAWAL_FROM_HIVE_ENGINE",
+    SWAP_TOKEN = "SWAP_TOKEN",
+    BUY_ON_HIVE_ENGINE_MARKET = "BUY_ON_HIVE_ENGINE_MARKET",
+    SELL_ON_HIVE_ENGINE_MARKET = "SELL_ON_HIVE_ENGINE_MARKET",
+    BUY_ON_MARKET = "BUY_ON_MARKET",
+    SELL_ON_MARKET = "SELL_ON_MARKET"
+}
+export declare enum Provider {
+    HIVE_INTERNAL_MARKET = "HIVE_INTERNAL_MARKET",
+    BEESWAP = "BEESWAP",
+    HIVE_PAY = "HIVE_PAY",
+    DISCOUNTED_BRIDGE = "DISCOUNTED_BRIDGE",
+    LEODEX = "LEODEX",
+    HIVE_ENGINE = "HIVE_ENGINE",
+    LIQUIDITY_POOL = "LIQUIDITY_POOL",
+    HIVE_ENGINE_INTERNAL_MARKET = "HIVE_ENGINE_INTERNAL_MARKET",
+    NULL = "NULL"
+}
+export declare enum SwapStatus {
+    PENDING = "PENDING",
+    STARTED = "STARTED",
+    CANCELED_DUE_TO_ERROR = "CANCELED_DUE_TO_ERROR",
+    REFUNDED_SLIPPAGE = "REFUND_SLIPPAGE",
+    COMPLETED = "COMPLETED",
+    FUNDS_RETURNED = "FUNDS_RETURNED"
+}
+export declare enum StepHistoryStatus {
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILED = "failed"
+}
+export interface ISwap {
+    id: string;
+    username: string;
+    startToken: string;
+    endToken: string;
+    amount: number;
+    expectedAmountAfterFee: number;
+    expectedAmountBeforeFee: number;
+    slipperage: number;
+    status: SwapStatus;
+    received: number;
+    fee: number;
+    feeTransactionId: string;
+    transferTransactionId: string;
+    steps: IStep[];
+    history: IStepHistory[];
+    createdAt: Date;
+    updatedAt: Date;
+    transferInitiated: boolean;
+}
+export interface IStepHistory {
+    id: number;
+    transactionId: string;
+    status: StepHistoryStatus;
+    type: SwapStepType;
+    stepNumber: number;
+    startToken: string;
+    amountStartToken: number;
+    endToken: string;
+    amountEndToken: number;
+    minimumExpectedAmount: number;
+    provider: Provider;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface IStep {
+    id: number;
+    type: SwapStepType;
+    stepNumber: number;
+    amountStartToken: number;
+    startToken: string;
+    estimate: number;
+    endToken: string;
+    provider: Provider;
+}

package/lib/swaps/swap.interface.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepHistoryStatus = exports.SwapStatus = exports.Provider = exports.SwapStepType = void 0;
+var SwapStepType;
+(function (SwapStepType) {
+    SwapStepType["DEPOSIT_TO_HIVE_ENGINE"] = "DEPOSIT_TO_HIVE_ENGINE";
+    SwapStepType["WITHDRAWAL_FROM_HIVE_ENGINE"] = "WITHDRAWAL_FROM_HIVE_ENGINE";
+    SwapStepType["SWAP_TOKEN"] = "SWAP_TOKEN";
+    SwapStepType["BUY_ON_HIVE_ENGINE_MARKET"] = "BUY_ON_HIVE_ENGINE_MARKET";
+    SwapStepType["SELL_ON_HIVE_ENGINE_MARKET"] = "SELL_ON_HIVE_ENGINE_MARKET";
+    SwapStepType["BUY_ON_MARKET"] = "BUY_ON_MARKET";
+    SwapStepType["SELL_ON_MARKET"] = "SELL_ON_MARKET";
+})(SwapStepType = exports.SwapStepType || (exports.SwapStepType = {}));
+var Provider;
+(function (Provider) {
+    Provider["HIVE_INTERNAL_MARKET"] = "HIVE_INTERNAL_MARKET";
+    Provider["BEESWAP"] = "BEESWAP";
+    Provider["HIVE_PAY"] = "HIVE_PAY";
+    Provider["DISCOUNTED_BRIDGE"] = "DISCOUNTED_BRIDGE";
+    Provider["LEODEX"] = "LEODEX";
+    Provider["HIVE_ENGINE"] = "HIVE_ENGINE";
+    Provider["LIQUIDITY_POOL"] = "LIQUIDITY_POOL";
+    Provider["HIVE_ENGINE_INTERNAL_MARKET"] = "HIVE_ENGINE_INTERNAL_MARKET";
+    Provider["NULL"] = "NULL";
+})(Provider = exports.Provider || (exports.Provider = {}));
+var SwapStatus;
+(function (SwapStatus) {
+    SwapStatus["PENDING"] = "PENDING";
+    SwapStatus["STARTED"] = "STARTED";
+    SwapStatus["CANCELED_DUE_TO_ERROR"] = "CANCELED_DUE_TO_ERROR";
+    SwapStatus["REFUNDED_SLIPPAGE"] = "REFUND_SLIPPAGE";
+    SwapStatus["COMPLETED"] = "COMPLETED";
+    SwapStatus["FUNDS_RETURNED"] = "FUNDS_RETURNED";
+})(SwapStatus = exports.SwapStatus || (exports.SwapStatus = {}));
+var StepHistoryStatus;
+(function (StepHistoryStatus) {
+    StepHistoryStatus["PENDING"] = "pending";
+    StepHistoryStatus["SUCCESS"] = "success";
+    StepHistoryStatus["FAILED"] = "failed";
+})(StepHistoryStatus = exports.StepHistoryStatus || (exports.StepHistoryStatus = {}));

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "hive-keychain-commons",
+  "version": "1.1.0",
+  "description": "Platform agnostic functions used in Hive Keychain mobile and extensions",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" ",
+    "lint": "tslint -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stoodkev/hive-keychain-commons.git"
+  },
+  "keywords": [
+    "hive",
+    "keychain",
+    "commons",
+    "blockchain",
+    "crypto",
+    "wallet"
+  ],
+  "author": "stoodkev",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/stoodkev/hive-keychain-commons/issues"
+  },
+  "homepage": "https://github.com/stoodkev/hive-keychain-commons#readme",
+  "devDependencies": {
+    "@types/bytebuffer": "^5.0.44",
+    "@types/node": "^18.11.19",
+    "prettier": "^2.4.1",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.5.2"
+  },
+  "dependencies": {
+    "@hiveio/dhive": "^1.2.5",
+    "moment": "^2.29.4",
+    "winston": "^3.8.1",
+    "winston-daily-rotate-file": "^4.7.1"
+  }
+}