hive-stream 3.0.4 → 3.0.5

package/dist/builders.js

@@ -1,6 +1,6 @@
 "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;
+exports.HiveCommunityOperationBuilder = exports.HiveEngineDelegateBuilder = exports.HiveEngineCancelOrderBuilder = exports.HiveEngineMarketOrderBuilder = exports.HiveEngineUnstakeBuilder = exports.HiveEngineStakeBuilder = exports.HiveBatchBuilder = exports.HivePostBuilder = exports.HiveCommentOptionsBuilder = exports.HiveWithdrawRouteBuilder = exports.HiveCancelOrderBuilder = exports.HiveLimitOrderBuilder = exports.HiveDeleteCommentBuilder = exports.HiveCollateralizedConvertBuilder = exports.HiveConvertBuilder = exports.HiveSavingsTransferBuilder = exports.HiveUpdateProfileBuilder = exports.HiveSetProxyBuilder = exports.HiveWitnessVoteBuilder = exports.HiveClaimRewardsBuilder = exports.HiveDelegateBuilder = exports.HivePowerDownBuilder = exports.HivePowerUpBuilder = exports.HiveReblogBuilder = exports.HiveFollowBuilder = 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') {
@@ -724,4 +724,886 @@ class HiveVoteBuilder {
     }
 }
 exports.HiveVoteBuilder = HiveVoteBuilder;
+class HiveFollowBuilder {
+    streamer;
+    mode;
+    state = {};
+    constructor(streamer, mode) {
+        this.streamer = streamer;
+        this.mode = mode;
+    }
+    follower(account) {
+        this.state.follower = account;
+        return this;
+    }
+    following(account) {
+        this.state.following = account;
+        return this;
+    }
+    send() {
+        if (!this.state.follower || !this.state.following) {
+            throw new Error(`${this.mode}() builder requires follower and following before send()`);
+        }
+        if (this.mode === 'follow') {
+            return this.streamer.follow(this.state.follower, this.state.following);
+        }
+        if (this.mode === 'mute') {
+            return this.streamer.mute(this.state.follower, this.state.following);
+        }
+        return this.streamer.unfollow(this.state.follower, this.state.following);
+    }
+}
+exports.HiveFollowBuilder = HiveFollowBuilder;
+class HiveReblogBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send() {
+        if (!this.state.account || !this.state.author || !this.state.permlink) {
+            throw new Error('reblog() builder requires account, author, and permlink before send()');
+        }
+        return this.streamer.reblog(this.state.account, this.state.author, this.state.permlink);
+    }
+}
+exports.HiveReblogBuilder = HiveReblogBuilder;
+class HivePowerUpBuilder {
+    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) {
+        this.state.amount = utils_1.Utils.formatAmount(amount);
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('powerUp() builder requires from and amount before send()');
+        }
+        return this.streamer.powerUp(this.state.from, this.state.to || this.state.from, this.state.amount);
+    }
+}
+exports.HivePowerUpBuilder = HivePowerUpBuilder;
+class HivePowerDownBuilder {
+    streamer;
+    cancel;
+    state = {};
+    constructor(streamer, cancel = false) {
+        this.streamer = streamer;
+        this.cancel = cancel;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    vestingShares(amount) {
+        this.state.vestingShares = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('powerDown() builder requires account before send()');
+        }
+        if (this.cancel) {
+            return this.streamer.cancelPowerDown(this.state.account);
+        }
+        if (!this.state.vestingShares) {
+            throw new Error('powerDown() builder requires vestingShares before send()');
+        }
+        return this.streamer.powerDown(this.state.account, this.state.vestingShares);
+    }
+}
+exports.HivePowerDownBuilder = HivePowerDownBuilder;
+class HiveDelegateBuilder {
+    streamer;
+    undelegate;
+    state = {};
+    constructor(streamer, undelegate = false) {
+        this.streamer = streamer;
+        this.undelegate = undelegate;
+    }
+    delegator(account) {
+        this.state.delegator = account;
+        return this;
+    }
+    delegatee(account) {
+        this.state.delegatee = account;
+        return this;
+    }
+    vestingShares(amount) {
+        this.state.vestingShares = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.delegator || !this.state.delegatee) {
+            throw new Error('delegate() builder requires delegator and delegatee before send()');
+        }
+        if (this.undelegate) {
+            return this.streamer.undelegateVestingShares(this.state.delegator, this.state.delegatee);
+        }
+        if (!this.state.vestingShares) {
+            throw new Error('delegate() builder requires vestingShares before send()');
+        }
+        return this.streamer.delegateVestingShares(this.state.delegator, this.state.delegatee, this.state.vestingShares);
+    }
+}
+exports.HiveDelegateBuilder = HiveDelegateBuilder;
+class HiveClaimRewardsBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    rewardHive(amount) {
+        this.state.rewardHive = amount;
+        return this;
+    }
+    rewardHbd(amount) {
+        this.state.rewardHbd = amount;
+        return this;
+    }
+    rewardVests(amount) {
+        this.state.rewardVests = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('claimRewards() builder requires account before send()');
+        }
+        return this.streamer.claimRewards(this.state.account, this.state.rewardHive || '0.000 HIVE', this.state.rewardHbd || '0.000 HBD', this.state.rewardVests || '0.000000 VESTS');
+    }
+}
+exports.HiveClaimRewardsBuilder = HiveClaimRewardsBuilder;
+class HiveWitnessVoteBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    witness(account) {
+        this.state.witness = account;
+        return this;
+    }
+    approve(value = true) {
+        this.state.approve = value;
+        return this;
+    }
+    unapprove() {
+        return this.approve(false);
+    }
+    send() {
+        if (!this.state.account || !this.state.witness) {
+            throw new Error('witnessVote() builder requires account and witness before send()');
+        }
+        return this.streamer.witnessVote(this.state.account, this.state.witness, this.state.approve !== false);
+    }
+}
+exports.HiveWitnessVoteBuilder = HiveWitnessVoteBuilder;
+class HiveSetProxyBuilder {
+    streamer;
+    clear;
+    state = {};
+    constructor(streamer, clear = false) {
+        this.streamer = streamer;
+        this.clear = clear;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    proxy(account) {
+        this.state.proxy = account;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('setProxy() builder requires account before send()');
+        }
+        if (this.clear) {
+            return this.streamer.clearProxy(this.state.account);
+        }
+        if (!this.state.proxy) {
+            throw new Error('setProxy() builder requires proxy before send()');
+        }
+        return this.streamer.setProxy(this.state.account, this.state.proxy);
+    }
+}
+exports.HiveSetProxyBuilder = HiveSetProxyBuilder;
+class HiveUpdateProfileBuilder {
+    streamer;
+    state = { profile: {} };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    name(value) {
+        this.state.profile.name = value;
+        return this;
+    }
+    about(value) {
+        this.state.profile.about = value;
+        return this;
+    }
+    location(value) {
+        this.state.profile.location = value;
+        return this;
+    }
+    website(value) {
+        this.state.profile.website = value;
+        return this;
+    }
+    profileImage(url) {
+        this.state.profile.profile_image = url;
+        return this;
+    }
+    coverImage(url) {
+        this.state.profile.cover_image = url;
+        return this;
+    }
+    set(key, value) {
+        this.state.profile[key] = value;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('updateProfile() builder requires account before send()');
+        }
+        if (Object.keys(this.state.profile).length === 0) {
+            throw new Error('updateProfile() builder requires at least one profile field before send()');
+        }
+        return this.streamer.updateProfile(this.state.account, this.state.profile);
+    }
+}
+exports.HiveUpdateProfileBuilder = HiveUpdateProfileBuilder;
+class HiveSavingsTransferBuilder {
+    streamer;
+    direction;
+    state = {};
+    constructor(streamer, direction) {
+        this.streamer = streamer;
+        this.direction = direction;
+    }
+    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;
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount || !this.state.symbol) {
+            throw new Error(`${this.direction === 'to' ? 'transferToSavings' : 'transferFromSavings'}() builder requires from and amount before send()`);
+        }
+        const to = this.state.to || this.state.from;
+        if (this.direction === 'to') {
+            return this.streamer.transferToSavings(this.state.from, to, this.state.amount, this.state.symbol, this.state.memo || '');
+        }
+        return this.streamer.transferFromSavings(this.state.from, to, this.state.amount, this.state.symbol, this.state.requestId || 0, this.state.memo || '');
+    }
+}
+exports.HiveSavingsTransferBuilder = HiveSavingsTransferBuilder;
+class HiveConvertBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('convert() builder requires from and amount before send()');
+        }
+        return this.streamer.convert(this.state.from, this.state.amount, this.state.requestId || 0);
+    }
+}
+exports.HiveConvertBuilder = HiveConvertBuilder;
+class HiveCollateralizedConvertBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol || 'HIVE');
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('collateralizedConvert() builder requires from and amount before send()');
+        }
+        return this.streamer.collateralizedConvert(this.state.from, this.state.amount, this.state.requestId || 0);
+    }
+}
+exports.HiveCollateralizedConvertBuilder = HiveCollateralizedConvertBuilder;
+class HiveDeleteCommentBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send() {
+        if (!this.state.author || !this.state.permlink) {
+            throw new Error('deleteComment() builder requires author and permlink before send()');
+        }
+        return this.streamer.deleteComment(this.state.author, this.state.permlink);
+    }
+}
+exports.HiveDeleteCommentBuilder = HiveDeleteCommentBuilder;
+class HiveLimitOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.owner = account;
+        return this;
+    }
+    orderId(id) {
+        this.state.orderId = id;
+        return this;
+    }
+    amountToSell(amount, symbol) {
+        this.state.amountToSell = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    minToReceive(amount, symbol) {
+        this.state.minToReceive = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    fillOrKill(value = true) {
+        this.state.fillOrKill = value;
+        return this;
+    }
+    expiration(value) {
+        this.state.expiration = value;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.owner || !this.state.amountToSell || !this.state.minToReceive) {
+            throw new Error('limitOrder() builder requires owner, amountToSell, and minToReceive before send()');
+        }
+        return this.streamer.limitOrderCreate(this.state.owner, this.state.orderId || Math.floor(Date.now() / 1000), this.state.amountToSell, this.state.minToReceive, this.state.fillOrKill || false, this.state.expiration, signingKeys);
+    }
+}
+exports.HiveLimitOrderBuilder = HiveLimitOrderBuilder;
+class HiveCancelOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.owner = account;
+        return this;
+    }
+    orderId(id) {
+        this.state.orderId = id;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.owner || this.state.orderId === undefined) {
+            throw new Error('cancelOrder() builder requires owner and orderId before send()');
+        }
+        return this.streamer.limitOrderCancel(this.state.owner, this.state.orderId, signingKeys);
+    }
+}
+exports.HiveCancelOrderBuilder = HiveCancelOrderBuilder;
+class HiveWithdrawRouteBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    percent(value) {
+        this.state.percent = value;
+        return this;
+    }
+    autoVest(value = true) {
+        this.state.autoVest = value;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.from || !this.state.to || this.state.percent === undefined) {
+            throw new Error('withdrawRoute() builder requires from, to, and percent before send()');
+        }
+        return this.streamer.setWithdrawVestingRoute(this.state.from, this.state.to, this.state.percent, this.state.autoVest || false, signingKeys);
+    }
+}
+exports.HiveWithdrawRouteBuilder = HiveWithdrawRouteBuilder;
+class HiveCommentOptionsBuilder {
+    streamer;
+    state = { beneficiaries: [] };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    maxAcceptedPayout(amount, symbol) {
+        this.state.maxAcceptedPayout = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    percentHbd(value) {
+        this.state.percentHbd = value;
+        return this;
+    }
+    allowVotes(value = true) {
+        this.state.allowVotes = value;
+        return this;
+    }
+    allowCurationRewards(value = true) {
+        this.state.allowCurationRewards = value;
+        return this;
+    }
+    beneficiary(account, weight) {
+        this.state.beneficiaries.push({ account, weight });
+        return this;
+    }
+    send() {
+        if (!this.state.author || !this.state.permlink) {
+            throw new Error('commentOptions() builder requires author and permlink before send()');
+        }
+        const extensions = [];
+        if (this.state.beneficiaries.length > 0) {
+            extensions.push([0, { beneficiaries: this.state.beneficiaries }]);
+        }
+        return this.streamer.commentOptions(this.state.author, this.state.permlink, {
+            max_accepted_payout: this.state.maxAcceptedPayout,
+            percent_hbd: this.state.percentHbd,
+            allow_votes: this.state.allowVotes,
+            allow_curation_rewards: this.state.allowCurationRewards,
+            extensions
+        });
+    }
+}
+exports.HiveCommentOptionsBuilder = HiveCommentOptionsBuilder;
+class HivePostBuilder {
+    streamer;
+    state = {
+        tags: [],
+        parentAuthor: '',
+        parentPermlink: '',
+        beneficiaries: [],
+        appName: 'hive-stream',
+        formatType: 'markdown',
+        images: [],
+        extraMetadata: {}
+    };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    title(value) {
+        this.state.title = value;
+        return this;
+    }
+    body(value) {
+        this.state.body = value;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    tags(...tags) {
+        this.state.tags = tags.map(t => t.trim().toLowerCase()).filter(Boolean);
+        return this;
+    }
+    community(name) {
+        this.state.communityName = name;
+        return this;
+    }
+    parentAuthor(account) {
+        this.state.parentAuthor = account;
+        return this;
+    }
+    parentPermlink(value) {
+        this.state.parentPermlink = value;
+        return this;
+    }
+    beneficiary(account, weight) {
+        this.state.beneficiaries.push({ account, weight });
+        return this;
+    }
+    maxAcceptedPayout(amount, symbol) {
+        this.state.maxAcceptedPayout = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    percentHbd(value) {
+        this.state.percentHbd = value;
+        return this;
+    }
+    allowVotes(value = true) {
+        this.state.allowVotes = value;
+        return this;
+    }
+    allowCurationRewards(value = true) {
+        this.state.allowCurationRewards = value;
+        return this;
+    }
+    app(name) {
+        this.state.appName = name;
+        return this;
+    }
+    format(value) {
+        this.state.formatType = value;
+        return this;
+    }
+    description(value) {
+        this.state.descriptionText = value;
+        return this;
+    }
+    image(...urls) {
+        this.state.images.push(...urls);
+        return this;
+    }
+    metadata(key, value) {
+        this.state.extraMetadata[key] = value;
+        return this;
+    }
+    send() {
+        if (!this.state.author) {
+            throw new Error('post() builder requires author before send()');
+        }
+        if (!this.state.body) {
+            throw new Error('post() builder requires body before send()');
+        }
+        const isReply = !!this.state.parentAuthor;
+        // Generate permlink if not provided
+        const permlink = this.state.permlink
+            || (isReply
+                ? utils_1.Utils.generateReplyPermlink(this.state.parentPermlink)
+                : utils_1.Utils.generatePermlink(this.state.title || 'untitled'));
+        // Determine parent_permlink for top-level posts
+        let parentPermlink = this.state.parentPermlink;
+        if (!isReply) {
+            if (this.state.communityName) {
+                parentPermlink = this.state.communityName;
+            }
+            else if (this.state.tags.length > 0) {
+                parentPermlink = this.state.tags[0];
+            }
+            else {
+                parentPermlink = 'hive-stream';
+            }
+        }
+        // Build json_metadata
+        const jsonMetadata = utils_1.Utils.createPostMetadata({
+            tags: this.state.tags,
+            image: this.state.images.length > 0 ? this.state.images : utils_1.Utils.extractImagesFromBody(this.state.body),
+            app: this.state.appName,
+            format: this.state.formatType,
+            description: this.state.descriptionText,
+            ...this.state.extraMetadata
+        });
+        // Build the comment operation
+        const commentOp = ['comment', {
+                parent_author: this.state.parentAuthor,
+                parent_permlink: parentPermlink,
+                author: this.state.author,
+                permlink,
+                title: this.state.title || '',
+                body: this.state.body,
+                json_metadata: jsonMetadata
+            }];
+        // Check if we need comment_options
+        const needsOptions = this.state.beneficiaries.length > 0
+            || this.state.maxAcceptedPayout !== undefined
+            || this.state.percentHbd !== undefined
+            || this.state.allowVotes !== undefined
+            || this.state.allowCurationRewards !== undefined;
+        if (!needsOptions) {
+            return this.streamer.broadcastOperations([commentOp]);
+        }
+        // Build comment_options operation
+        const extensions = [];
+        if (this.state.beneficiaries.length > 0) {
+            const sorted = [...this.state.beneficiaries].sort((a, b) => a.account.localeCompare(b.account));
+            extensions.push([0, { beneficiaries: sorted }]);
+        }
+        const commentOptionsOp = ['comment_options', {
+                author: this.state.author,
+                permlink,
+                max_accepted_payout: this.state.maxAcceptedPayout || '1000000.000 HBD',
+                percent_hbd: this.state.percentHbd !== undefined ? this.state.percentHbd : 10000,
+                allow_votes: this.state.allowVotes !== false,
+                allow_curation_rewards: this.state.allowCurationRewards !== false,
+                extensions
+            }];
+        // Broadcast both atomically
+        return this.streamer.broadcastOperations([commentOp, commentOptionsOp]);
+    }
+}
+exports.HivePostBuilder = HivePostBuilder;
+class HiveBatchBuilder {
+    streamer;
+    operations = [];
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    add(operation) {
+        this.operations.push(operation);
+        return this;
+    }
+    transfer(from, to, amount, memo = '') {
+        this.operations.push(['transfer', { from, to, amount, memo }]);
+        return this;
+    }
+    vote(voter, author, permlink, weight) {
+        this.operations.push(['vote', { voter, author, permlink, weight }]);
+        return this;
+    }
+    customJson(id, json, postingAuth, activeAuth) {
+        const jsonStr = typeof json === 'string' ? json : JSON.stringify(json);
+        this.operations.push(['custom_json', {
+                required_auths: activeAuth ? [activeAuth] : [],
+                required_posting_auths: postingAuth ? [postingAuth] : [],
+                id,
+                json: jsonStr
+            }]);
+        return this;
+    }
+    comment(author, permlink, parentAuthor, parentPermlink, title, body, jsonMetadata = '{}') {
+        this.operations.push(['comment', {
+                parent_author: parentAuthor,
+                parent_permlink: parentPermlink,
+                author,
+                permlink,
+                title,
+                body,
+                json_metadata: jsonMetadata
+            }]);
+        return this;
+    }
+    send(signingKeys) {
+        if (this.operations.length === 0) {
+            throw new Error('batch() builder requires at least one operation before send()');
+        }
+        return this.streamer.broadcastOperations(this.operations, signingKeys);
+    }
+}
+exports.HiveBatchBuilder = HiveBatchBuilder;
+class HiveEngineStakeBuilder {
+    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; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity) {
+            throw new Error('stakeEngine() builder requires from, symbol, and quantity before send()');
+        }
+        return this.streamer.stakeEngineTokens(this.state.from, this.state.to || this.state.from, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineStakeBuilder = HiveEngineStakeBuilder;
+class HiveEngineUnstakeBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) { this.state.from = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity) {
+            throw new Error('unstakeEngine() builder requires from, symbol, and quantity before send()');
+        }
+        return this.streamer.unstakeEngineTokens(this.state.from, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineUnstakeBuilder = HiveEngineUnstakeBuilder;
+class HiveEngineMarketOrderBuilder {
+    streamer;
+    side;
+    state = {};
+    constructor(streamer, side) {
+        this.streamer = streamer;
+        this.side = side;
+    }
+    from(account) { this.state.from = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    price(price) { this.state.price = String(price); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity || !this.state.price) {
+            throw new Error(`${this.side}Engine() builder requires from, symbol, quantity, and price before send()`);
+        }
+        if (this.side === 'buy') {
+            return this.streamer.buyEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.price);
+        }
+        return this.streamer.sellEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.price);
+    }
+}
+exports.HiveEngineMarketOrderBuilder = HiveEngineMarketOrderBuilder;
+class HiveEngineCancelOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) { this.state.from = account; return this; }
+    type(type) { this.state.type = type; return this; }
+    orderId(id) { this.state.orderId = id; return this; }
+    send() {
+        if (!this.state.from || !this.state.type || !this.state.orderId) {
+            throw new Error('cancelEngineOrder() builder requires from, type, and orderId before send()');
+        }
+        return this.streamer.cancelEngineOrder(this.state.from, this.state.type, this.state.orderId);
+    }
+}
+exports.HiveEngineCancelOrderBuilder = HiveEngineCancelOrderBuilder;
+class HiveEngineDelegateBuilder {
+    streamer;
+    undelegate;
+    state = {};
+    constructor(streamer, undelegate = false) {
+        this.streamer = streamer;
+        this.undelegate = undelegate;
+    }
+    from(account) { this.state.from = account; return this; }
+    to(account) { this.state.to = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.to || !this.state.symbol || !this.state.quantity) {
+            throw new Error(`${this.undelegate ? 'undelegateEngine' : 'delegateEngine'}() builder requires from, to, symbol, and quantity before send()`);
+        }
+        if (this.undelegate) {
+            return this.streamer.undelegateEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity);
+        }
+        return this.streamer.delegateEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineDelegateBuilder = HiveEngineDelegateBuilder;
+class HiveCommunityOperationBuilder {
+    streamer;
+    action;
+    state = {};
+    constructor(streamer, action) {
+        this.streamer = streamer;
+        this.action = action;
+    }
+    account(account) { this.state.account = account; return this; }
+    community(name) { this.state.community = name; return this; }
+    send() {
+        if (!this.state.account || !this.state.community) {
+            throw new Error(`${this.action}Community() builder requires account and community before send()`);
+        }
+        if (this.action === 'subscribe') {
+            return this.streamer.subscribeCommunity(this.state.account, this.state.community);
+        }
+        return this.streamer.unsubscribeCommunity(this.state.account, this.state.community);
+    }
+}
+exports.HiveCommunityOperationBuilder = HiveCommunityOperationBuilder;
 //# sourceMappingURL=builders.js.map