hive-stream 3.0.2 → 3.0.4

package/dist/builders.js

@@ -0,0 +1,727 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HiveVoteBuilder = exports.HiveRemoveProposalsBuilder = exports.HiveProposalVotesBuilder = exports.HiveEngineTokenIssueBuilder = exports.HiveEngineTokenBurnBuilder = exports.HiveEngineTokenTransferBuilder = exports.HiveProposalBuilder = exports.HiveRecurrentTransferBuilder = exports.HiveEscrowTransferBuilder = exports.HiveBurnBuilder = exports.HiveTransferBuilder = exports.IncomingTransfersBuilder = void 0;
+const utils_1 = require("./utils");
+function normalizeAllocationInput(input, context) {
+    if (typeof input === 'number') {
+        return { percentage: input };
+    }
+    if (typeof input === 'string') {
+        const value = input.trim();
+        if (!/^-?\d+(\.\d+)?$/.test(value)) {
+            throw new Error(`${context} allocation string must be numeric`);
+        }
+        return { percentage: value };
+    }
+    if (!input || typeof input !== 'object') {
+        throw new Error(`${context} allocation is required`);
+    }
+    const percentage = input.percentage ?? input.percent;
+    const basisPoints = input.basisPoints;
+    if (percentage !== undefined && basisPoints !== undefined) {
+        throw new Error(`${context} accepts either percentage or basisPoints, not both`);
+    }
+    if (percentage === undefined && basisPoints === undefined) {
+        throw new Error(`${context} allocation is required`);
+    }
+    return {
+        percentage: input.percentage,
+        percent: input.percent,
+        basisPoints: input.basisPoints
+    };
+}
+function resolveRouteMemo(stepMemo, defaultMemo) {
+    return stepMemo !== undefined ? stepMemo : defaultMemo;
+}
+function normalizeGroupRecipients(recipients, context) {
+    if (!Array.isArray(recipients) || recipients.length === 0) {
+        throw new Error(`${context} requires at least one group recipient`);
+    }
+    return recipients.map((recipient, index) => {
+        if (!recipient || typeof recipient !== 'object') {
+            throw new Error(`${context} recipient ${index + 1} is invalid`);
+        }
+        if (typeof recipient.account === 'string') {
+            const account = recipient.account.trim();
+            if (!account) {
+                throw new Error(`${context} recipient ${index + 1} account is required`);
+            }
+            return {
+                account,
+                weight: recipient.weight
+            };
+        }
+        if (typeof recipient.account !== 'function') {
+            throw new Error(`${context} recipient ${index + 1} account is required`);
+        }
+        return recipient;
+    });
+}
+function parseAssetInput(amount, symbol) {
+    if (symbol) {
+        return {
+            amount: utils_1.Utils.formatAmount(amount),
+            symbol: symbol.trim()
+        };
+    }
+    if (typeof amount === 'string' && amount.includes(' ')) {
+        const parsed = utils_1.Utils.parseAssetAmount(amount);
+        return {
+            amount: utils_1.Utils.formatAmount(parsed.amount),
+            symbol: parsed.asset
+        };
+    }
+    throw new Error('Provide a symbol or an asset amount string like "1.000 HIVE"');
+}
+function buildAssetAmount(amount, symbol) {
+    const parsed = parseAssetInput(amount, symbol);
+    return utils_1.Utils.formatAssetAmount(parsed.amount, parsed.symbol);
+}
+function normalizeEngineQuantity(quantity) {
+    const normalized = String(quantity).trim();
+    if (!normalized) {
+        throw new Error('Quantity is required');
+    }
+    return normalized;
+}
+class IncomingTransfersBuilder {
+    streamer;
+    account;
+    allowedSymbols;
+    dedupeStore;
+    ignoreZeroAmountValue;
+    errorHandler;
+    defaultMemo;
+    steps = [];
+    constructor(streamer, account) {
+        this.streamer = streamer;
+        this.account = account;
+    }
+    forAccount(account) {
+        this.account = account;
+        return this;
+    }
+    allowSymbols(...symbols) {
+        this.allowedSymbols = symbols.map((symbol) => symbol.trim()).filter(Boolean);
+        return this;
+    }
+    memo(memo) {
+        this.defaultMemo = memo;
+        return this;
+    }
+    dedupeWith(store) {
+        this.dedupeStore = store;
+        return this;
+    }
+    ignoreZeroAmount(ignore = true) {
+        this.ignoreZeroAmountValue = ignore;
+        return this;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    burn(allocation, memo) {
+        this.steps.push({
+            type: 'burn',
+            ...normalizeAllocationInput(allocation, 'burn()'),
+            memo
+        });
+        return this;
+    }
+    burnOnTop(allocation, memo) {
+        this.steps.push({
+            type: 'burn',
+            mode: 'onTop',
+            ...normalizeAllocationInput(allocation, 'burnOnTop()'),
+            memo
+        });
+        return this;
+    }
+    forwardTo(to, allocation, memo) {
+        if (typeof to !== 'string' || to.trim().length === 0) {
+            throw new Error('forwardTo() requires a destination account');
+        }
+        this.steps.push({
+            type: 'transfer',
+            to: to.trim(),
+            ...(allocation === undefined ? {} : normalizeAllocationInput(allocation, 'forwardTo()')),
+            memo
+        });
+        return this;
+    }
+    forwardOnTop(to, allocation, memo) {
+        if (typeof to !== 'string' || to.trim().length === 0) {
+            throw new Error('forwardOnTop() requires a destination account');
+        }
+        this.steps.push({
+            type: 'transfer',
+            mode: 'onTop',
+            to: to.trim(),
+            ...normalizeAllocationInput(allocation, 'forwardOnTop()'),
+            memo
+        });
+        return this;
+    }
+    donateOnTop(to, allocation, memo) {
+        return this.forwardOnTop(to, allocation, memo);
+    }
+    forwardGroup(recipients, allocation, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            group: normalizeGroupRecipients(recipients, 'forwardGroup()'),
+            split: options.split,
+            ...normalizeAllocationInput(allocation, 'forwardGroup()'),
+            memo: options.memo
+        });
+        return this;
+    }
+    forwardGroupOnTop(recipients, allocation, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            mode: 'onTop',
+            group: normalizeGroupRecipients(recipients, 'forwardGroupOnTop()'),
+            split: options.split,
+            ...normalizeAllocationInput(allocation, 'forwardGroupOnTop()'),
+            memo: options.memo
+        });
+        return this;
+    }
+    remainderTo(to, memo) {
+        return this.forwardTo(to, undefined, memo);
+    }
+    remainderToGroup(recipients, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            group: normalizeGroupRecipients(recipients, 'remainderToGroup()'),
+            split: options.split,
+            memo: options.memo
+        });
+        return this;
+    }
+    refund(memo) {
+        this.steps.push({
+            type: 'refund',
+            memo
+        });
+        return this;
+    }
+    refundPortion(allocation, memo) {
+        this.steps.push({
+            type: 'refund',
+            ...normalizeAllocationInput(allocation, 'refundPortion()'),
+            memo
+        });
+        return this;
+    }
+    remainderToSender(memo) {
+        return this.refund(memo);
+    }
+    plan(transfer) {
+        const commonOptions = {
+            routes: this.buildRoutes(),
+            allowedSymbols: this.allowedSymbols
+        };
+        return this.streamer.planIncomingTransferRoutes(transfer, commonOptions);
+    }
+    start() {
+        if (this.steps.length === 0) {
+            throw new Error('Add at least one builder step before calling start()');
+        }
+        const commonOptions = {
+            account: this.account,
+            allowedSymbols: this.allowedSymbols,
+            dedupeStore: this.dedupeStore,
+            ignoreZeroAmount: this.ignoreZeroAmountValue,
+            onError: this.errorHandler
+        };
+        if (this.steps.length === 1 && !this.steps[0].group && this.steps[0].mode !== 'onTop') {
+            const step = this.steps[0];
+            const memo = resolveRouteMemo(step.memo, this.defaultMemo);
+            if (step.type === 'burn') {
+                return this.streamer.autoBurnIncomingTransfers({
+                    ...commonOptions,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                });
+            }
+            if (step.type === 'refund') {
+                return this.streamer.autoRefundIncomingTransfers({
+                    ...commonOptions,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                });
+            }
+            return this.streamer.autoForwardIncomingTransfers({
+                ...commonOptions,
+                to: step.to,
+                percentage: step.percentage,
+                percent: step.percent,
+                basisPoints: step.basisPoints,
+                memo
+            });
+        }
+        const options = {
+            ...commonOptions,
+            routes: this.buildRoutes()
+        };
+        return this.streamer.autoRouteIncomingTransfers(options);
+    }
+    buildRoutes() {
+        if (this.steps.length === 0) {
+            throw new Error('Add at least one builder step before planning or starting a flow');
+        }
+        return this.steps.map((step) => {
+            const memo = resolveRouteMemo(step.memo, this.defaultMemo);
+            if (step.type === 'burn') {
+                return {
+                    type: 'burn',
+                    mode: step.mode,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            if (step.type === 'refund') {
+                return {
+                    mode: step.mode,
+                    to: (event) => event.transfer.from,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            if (step.group) {
+                return {
+                    mode: step.mode,
+                    group: step.group,
+                    split: step.split,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            return {
+                mode: step.mode,
+                to: step.to,
+                percentage: step.percentage,
+                percent: step.percent,
+                basisPoints: step.basisPoints,
+                memo
+            };
+        });
+    }
+}
+exports.IncomingTransfersBuilder = IncomingTransfersBuilder;
+class HiveTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        const parsed = parseAssetInput(amount, symbol);
+        this.state.amount = parsed.amount;
+        this.state.symbol = parsed.symbol;
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.to || !this.state.amount || !this.state.symbol) {
+            throw new Error('transfer() builder requires from, to, and amount before send()');
+        }
+        return this.streamer.transferHiveTokens(this.state.from, this.state.to, this.state.amount, this.state.symbol, this.state.memo || '');
+    }
+}
+exports.HiveTransferBuilder = HiveTransferBuilder;
+class HiveBurnBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        const parsed = parseAssetInput(amount, symbol);
+        this.state.amount = parsed.amount;
+        this.state.symbol = parsed.symbol;
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount || !this.state.symbol) {
+            throw new Error('burn() builder requires from and amount before send()');
+        }
+        return this.streamer.burnHiveTokens(this.state.from, this.state.amount, this.state.symbol, this.state.memo || '');
+    }
+}
+exports.HiveBurnBuilder = HiveBurnBuilder;
+class HiveEscrowTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    agent(account) {
+        this.state.agent = account;
+        return this;
+    }
+    id(escrowId) {
+        this.state.escrow_id = escrowId;
+        return this;
+    }
+    hive(amount) {
+        this.state.hive_amount = buildAssetAmount(amount, 'HIVE');
+        return this;
+    }
+    hbd(amount) {
+        this.state.hbd_amount = buildAssetAmount(amount, 'HBD');
+        return this;
+    }
+    fee(amount, symbol) {
+        this.state.fee = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    ratificationDeadline(value) {
+        this.state.ratification_deadline = value;
+        return this;
+    }
+    expiration(value) {
+        this.state.escrow_expiration = value;
+        return this;
+    }
+    jsonMeta(meta) {
+        this.state.json_meta = meta;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.escrowTransfer({
+            from: this.state.from,
+            to: this.state.to,
+            agent: this.state.agent,
+            escrow_id: this.state.escrow_id,
+            hive_amount: this.state.hive_amount,
+            hbd_amount: this.state.hbd_amount,
+            fee: this.state.fee,
+            ratification_deadline: this.state.ratification_deadline,
+            escrow_expiration: this.state.escrow_expiration,
+            json_meta: this.state.json_meta
+        }, signingKeys);
+    }
+}
+exports.HiveEscrowTransferBuilder = HiveEscrowTransferBuilder;
+class HiveRecurrentTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    recurrence(value) {
+        this.state.recurrence = value;
+        return this;
+    }
+    executions(value) {
+        this.state.executions = value;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.recurrentTransfer({
+            from: this.state.from,
+            to: this.state.to,
+            amount: this.state.amount,
+            memo: this.state.memo,
+            recurrence: this.state.recurrence,
+            executions: this.state.executions
+        }, signingKeys);
+    }
+}
+exports.HiveRecurrentTransferBuilder = HiveRecurrentTransferBuilder;
+class HiveProposalBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    creator(account) {
+        this.state.creator = account;
+        return this;
+    }
+    receiver(account) {
+        this.state.receiver = account;
+        return this;
+    }
+    startDate(value) {
+        this.state.start_date = value;
+        return this;
+    }
+    endDate(value) {
+        this.state.end_date = value;
+        return this;
+    }
+    dailyPay(amount, symbol) {
+        this.state.daily_pay = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    dailyHive(amount) {
+        return this.dailyPay(amount, 'HIVE');
+    }
+    dailyHbd(amount) {
+        return this.dailyPay(amount, 'HBD');
+    }
+    subject(value) {
+        this.state.subject = value;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.createProposal({
+            creator: this.state.creator,
+            receiver: this.state.receiver,
+            start_date: this.state.start_date,
+            end_date: this.state.end_date,
+            daily_pay: this.state.daily_pay,
+            subject: this.state.subject,
+            permlink: this.state.permlink
+        }, signingKeys);
+    }
+}
+exports.HiveProposalBuilder = HiveProposalBuilder;
+class HiveEngineTokenTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.transferHiveEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenTransferBuilder = HiveEngineTokenTransferBuilder;
+class HiveEngineTokenBurnBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.burnHiveEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenBurnBuilder = HiveEngineTokenBurnBuilder;
+class HiveEngineTokenIssueBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.issueHiveEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenIssueBuilder = HiveEngineTokenIssueBuilder;
+class HiveProposalVotesBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    voter(account) {
+        this.state.voter = account;
+        return this;
+    }
+    ids(...proposalIds) {
+        this.state.proposal_ids = proposalIds;
+        return this;
+    }
+    approve(value = true) {
+        this.state.approve = value;
+        return this;
+    }
+    reject() {
+        return this.approve(false);
+    }
+    send(signingKeys) {
+        return this.streamer.updateProposalVotes({
+            voter: this.state.voter,
+            proposal_ids: this.state.proposal_ids,
+            approve: this.state.approve
+        }, signingKeys);
+    }
+}
+exports.HiveProposalVotesBuilder = HiveProposalVotesBuilder;
+class HiveRemoveProposalsBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.proposal_owner = account;
+        return this;
+    }
+    ids(...proposalIds) {
+        this.state.proposal_ids = proposalIds;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.removeProposals({
+            proposal_owner: this.state.proposal_owner,
+            proposal_ids: this.state.proposal_ids
+        }, signingKeys);
+    }
+}
+exports.HiveRemoveProposalsBuilder = HiveRemoveProposalsBuilder;
+class HiveVoteBuilder {
+    streamer;
+    direction;
+    state = {};
+    constructor(streamer, direction) {
+        this.streamer = streamer;
+        this.direction = direction;
+    }
+    author(account) {
+        this.state.username = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    weight(value) {
+        this.state.weight = String(value);
+        return this;
+    }
+    send() {
+        if (this.direction === 'upvote') {
+            return this.streamer.upvote(this.state.weight || '100.0', this.state.username, this.state.permlink);
+        }
+        return this.streamer.downvote(this.state.weight || '100.0', this.state.username, this.state.permlink);
+    }
+}
+exports.HiveVoteBuilder = HiveVoteBuilder;
+//# sourceMappingURL=builders.js.map