@bithomp/xrpl-api 2.3.6

package/lib/v1/ledger/parse/settings.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = __importStar(require("lodash"));
+const assert = __importStar(require("assert"));
+const account_info_1 = require("../../../models/account_info");
+const common_1 = require("../../common");
+const fields_1 = __importDefault(require("./fields"));
+const memos_1 = __importDefault(require("./memos"));
+function getAccountRootModifiedNode(tx) {
+    const modifiedNodes = tx.meta.AffectedNodes.filter(node => node.ModifiedNode?.LedgerEntryType === 'AccountRoot');
+    assert.ok(modifiedNodes.length === 1);
+    return modifiedNodes[0].ModifiedNode;
+}
+function parseFlags(tx) {
+    const settings = {};
+    if (tx.TransactionType !== 'AccountSet') {
+        return settings;
+    }
+    const node = getAccountRootModifiedNode(tx);
+    const oldFlags = _.get(node.PreviousFields, 'Flags');
+    const newFlags = _.get(node.FinalFields, 'Flags');
+    if (oldFlags != null && newFlags != null) {
+        const changedFlags = oldFlags ^ newFlags;
+        const setFlags = newFlags & changedFlags;
+        const clearedFlags = oldFlags & changedFlags;
+        Object.entries(account_info_1.AccountRootFlagsKeys).forEach(entry => {
+            const [flagName, flagValue] = entry;
+            if (setFlags & flagValue) {
+                settings[flagName] = true;
+            }
+            else if (clearedFlags & flagValue) {
+                settings[flagName] = false;
+            }
+        });
+    }
+    const oldField = _.get(node.PreviousFields, 'AccountTxnID');
+    const newField = _.get(node.FinalFields, 'AccountTxnID');
+    if (newField && !oldField) {
+        settings.enableTransactionIDTracking = true;
+    }
+    else if (oldField && !newField) {
+        settings.enableTransactionIDTracking = false;
+    }
+    return settings;
+}
+function parseSettings(tx) {
+    const txType = tx.TransactionType;
+    assert.ok(txType === 'AccountSet' ||
+        txType === 'SetRegularKey' ||
+        txType === 'SignerListSet');
+    const baseSettings = (0, common_1.removeUndefined)({
+        memos: (0, memos_1.default)(tx),
+    });
+    return Object.assign(baseSettings, parseFlags(tx), (0, fields_1.default)(tx));
+}
+exports.default = parseSettings;

package/lib/v1/ledger/parse/ticket-create.d.ts

@@ -0,0 +1,2 @@
+declare function parseTicketCreate(tx: any): object;
+export default parseTicketCreate;

package/lib/v1/ledger/parse/ticket-create.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const common_1 = require("../../common");
+const memos_1 = __importDefault(require("./memos"));
+function parseTicketCreate(tx) {
+    assert.ok(tx.TransactionType === 'TicketCreate');
+    return (0, common_1.removeUndefined)({
+        memos: (0, memos_1.default)(tx),
+        ticketCount: tx.TicketCount
+    });
+}
+exports.default = parseTicketCreate;

package/lib/v1/ledger/parse/transaction.d.ts

@@ -0,0 +1,3 @@
+declare function parseTransactionType(type: any): any;
+declare function parseTransaction(tx: any, includeRawTransaction: boolean): any;
+export { parseTransactionType, parseTransaction };

package/lib/v1/ledger/parse/transaction.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTransaction = exports.parseTransactionType = void 0;
+const common_1 = require("../../common");
+const parse_outcome_1 = __importDefault(require("../parse_outcome"));
+const settings_1 = __importDefault(require("./settings"));
+const account_delete_1 = __importDefault(require("./account-delete"));
+const check_cancel_1 = __importDefault(require("./check-cancel"));
+const check_cash_1 = __importDefault(require("./check-cash"));
+const check_create_1 = __importDefault(require("./check-create"));
+const deposit_preauth_1 = __importDefault(require("./deposit-preauth"));
+const escrow_cancellation_1 = __importDefault(require("./escrow-cancellation"));
+const escrow_creation_1 = __importDefault(require("./escrow-creation"));
+const escrow_execution_1 = __importDefault(require("./escrow-execution"));
+const cancellation_1 = __importDefault(require("./cancellation"));
+const order_1 = __importDefault(require("./order"));
+const payment_1 = __importDefault(require("./payment"));
+const payment_channel_claim_1 = __importDefault(require("./payment-channel-claim"));
+const payment_channel_create_1 = __importDefault(require("./payment-channel-create"));
+const payment_channel_fund_1 = __importDefault(require("./payment-channel-fund"));
+const ticket_create_1 = __importDefault(require("./ticket-create"));
+const trustline_1 = __importDefault(require("./trustline"));
+const account_nfts_1 = require("../../../models/account_nfts");
+const amendment_1 = __importDefault(require("./amendment"));
+const fee_update_1 = __importDefault(require("./fee-update"));
+const transactionTypeToType = {
+    AccountSet: 'settings',
+    AccountDelete: 'accountDelete',
+    CheckCancel: 'checkCancel',
+    CheckCash: 'checkCash',
+    CheckCreate: 'checkCreate',
+    DepositPreauth: 'depositPreauth',
+    EscrowCancel: 'escrowCancellation',
+    EscrowCreate: 'escrowCreation',
+    EscrowFinish: 'escrowExecution',
+    OfferCancel: 'orderCancellation',
+    OfferCreate: 'order',
+    Payment: 'payment',
+    PaymentChannelClaim: 'paymentChannelClaim',
+    PaymentChannelCreate: 'paymentChannelCreate',
+    PaymentChannelFund: 'paymentChannelFund',
+    SetRegularKey: 'settings',
+    SignerListSet: 'settings',
+    TicketCreate: 'ticketCreate',
+    TrustSet: 'trustline',
+    NFTokenBurn: 'nftokenBurn',
+    NFTokenMint: 'nftokenMint',
+    NFTokenCancelOffer: 'nftokenCancelOffer',
+    NFTokenCreateOffer: 'nftokenCreateOffer',
+    NFTokenAcceptOffer: 'nftokenAcceptOffer',
+    EnableAmendment: 'amendment',
+    SetFee: 'feeUpdate'
+};
+function parseTransactionType(type) {
+    return transactionTypeToType[type] || null;
+}
+exports.parseTransactionType = parseTransactionType;
+const parserTypeFunc = {
+    settings: settings_1.default,
+    accountDelete: account_delete_1.default,
+    checkCancel: check_cancel_1.default,
+    checkCash: check_cash_1.default,
+    checkCreate: check_create_1.default,
+    depositPreauth: deposit_preauth_1.default,
+    escrowCancellation: escrow_cancellation_1.default,
+    escrowCreation: escrow_creation_1.default,
+    escrowExecution: escrow_execution_1.default,
+    orderCancellation: cancellation_1.default,
+    order: order_1.default,
+    payment: payment_1.default,
+    paymentChannelClaim: payment_channel_claim_1.default,
+    paymentChannelCreate: payment_channel_create_1.default,
+    paymentChannelFund: payment_channel_fund_1.default,
+    ticketCreate: ticket_create_1.default,
+    trustline: trustline_1.default,
+    nftokenBurn: account_nfts_1.parseNFTokenBurn,
+    nftokenMint: account_nfts_1.parseNFTokenMint,
+    nftokenCancelOffer: account_nfts_1.parseNFTokenCancelOffer,
+    nftokenCreateOffer: account_nfts_1.parseNFTokenCreateOffer,
+    nftokenAcceptOffer: account_nfts_1.parseNFTokenAcceptOffer,
+    amendment: amendment_1.default,
+    feeUpdate: fee_update_1.default
+};
+function parseTransaction(tx, includeRawTransaction) {
+    const type = parseTransactionType(tx.TransactionType);
+    const parser = parserTypeFunc[type];
+    const specification = parser
+        ? parser(tx)
+        : {
+            UNAVAILABLE: 'Unrecognized transaction type.',
+            SEE_RAW_TRANSACTION: 'Since this type is unrecognized, `rawTransaction` is included in this response.'
+        };
+    if (!parser) {
+        includeRawTransaction = true;
+    }
+    const outcome = (0, parse_outcome_1.default)(tx);
+    return (0, common_1.removeUndefined)({
+        type: type,
+        address: tx.Account,
+        sequence: tx.Sequence,
+        id: tx.hash,
+        specification: (0, common_1.removeUndefined)(specification),
+        outcome: outcome ? (0, common_1.removeUndefined)(outcome) : undefined,
+        rawTransaction: includeRawTransaction ? JSON.stringify(tx) : undefined
+    });
+}
+exports.parseTransaction = parseTransaction;

package/lib/v1/ledger/parse/trustline.d.ts

@@ -0,0 +1,2 @@
+declare function parseTrustline(tx: any): object;
+export default parseTrustline;

package/lib/v1/ledger/parse/trustline.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const xrpl_1 = require("xrpl");
+const utils_1 = require("./utils");
+const common_1 = require("../../common");
+const memos_1 = __importDefault(require("./memos"));
+function parseFlag(flagsValue, trueValue, falseValue) {
+    if (flagsValue & trueValue) {
+        return true;
+    }
+    if (flagsValue & falseValue) {
+        return false;
+    }
+    return undefined;
+}
+function parseTrustline(tx) {
+    assert.ok(tx.TransactionType === 'TrustSet');
+    return (0, common_1.removeUndefined)({
+        limit: tx.LimitAmount.value,
+        currency: tx.LimitAmount.currency,
+        counterparty: tx.LimitAmount.issuer,
+        memos: (0, memos_1.default)(tx),
+        qualityIn: (0, utils_1.parseQuality)(tx.QualityIn),
+        qualityOut: (0, utils_1.parseQuality)(tx.QualityOut),
+        ripplingDisabled: parseFlag(tx.Flags, xrpl_1.TrustSetFlags.tfSetNoRipple, xrpl_1.TrustSetFlags.tfClearNoRipple),
+        frozen: parseFlag(tx.Flags, xrpl_1.TrustSetFlags.tfSetFreeze, xrpl_1.TrustSetFlags.tfClearFreeze),
+        authorized: parseFlag(tx.Flags, xrpl_1.TrustSetFlags.tfSetfAuth, 0)
+    });
+}
+exports.default = parseTrustline;

package/lib/v1/ledger/parse/utils.d.ts

@@ -0,0 +1,6 @@
+declare function adjustQualityForXRP(quality: string, takerGetsCurrency: string, takerPaysCurrency: string): string;
+declare function parseQuality(quality?: number | null): number | undefined;
+declare function parseTimestamp(rippleTime?: number | null): string | undefined;
+declare function isPartialPayment(tx: any): boolean;
+declare function hexToString(hex: string): string | undefined;
+export { parseQuality, hexToString, parseTimestamp, adjustQualityForXRP, isPartialPayment };

package/lib/v1/ledger/parse/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPartialPayment = exports.adjustQualityForXRP = exports.parseTimestamp = exports.hexToString = exports.parseQuality = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const xrpl_1 = require("xrpl");
+const common = __importStar(require("../../common"));
+function adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency) {
+    const numeratorShift = takerPaysCurrency === 'XRP' ? -6 : 0;
+    const denominatorShift = takerGetsCurrency === 'XRP' ? -6 : 0;
+    const shift = numeratorShift - denominatorShift;
+    return shift === 0
+        ? quality
+        : new bignumber_js_1.default(quality).shiftedBy(shift).toString();
+}
+exports.adjustQualityForXRP = adjustQualityForXRP;
+function parseQuality(quality) {
+    if (typeof quality !== 'number') {
+        return undefined;
+    }
+    return new bignumber_js_1.default(quality).shiftedBy(-9).toNumber();
+}
+exports.parseQuality = parseQuality;
+function parseTimestamp(rippleTime) {
+    if (typeof rippleTime !== 'number') {
+        return undefined;
+    }
+    return common.rippleTimeToISO8601(rippleTime);
+}
+exports.parseTimestamp = parseTimestamp;
+function isPartialPayment(tx) {
+    return (tx.Flags & xrpl_1.PaymentFlags.tfPartialPayment) !== 0;
+}
+exports.isPartialPayment = isPartialPayment;
+function hexToString(hex) {
+    return hex ? Buffer.from(hex, 'hex').toString('utf-8') : undefined;
+}
+exports.hexToString = hexToString;

package/lib/v1/ledger/parse_outcome.d.ts

@@ -0,0 +1,2 @@
+declare function parseOutcome(tx: any): any | undefined;
+export default parseOutcome;

package/lib/v1/ledger/parse_outcome.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const transaction_1 = require("../../models/transaction");
+const amount_1 = __importDefault(require("./parse/amount"));
+const utils_1 = require("./parse/utils");
+const common_1 = require("../common");
+function removeEmptyCounterparty(amount) {
+    if (amount.counterparty === '') {
+        delete amount.counterparty;
+    }
+}
+function removeEmptyCounterpartyInBalanceChanges(balanceChanges) {
+    Object.entries(balanceChanges).forEach(([_, changes]) => {
+        changes.forEach(removeEmptyCounterparty);
+    });
+}
+function removeEmptyCounterpartyInOrderbookChanges(orderbookChanges) {
+    Object.entries(orderbookChanges).forEach(([_, changes]) => {
+        changes.forEach((change) => {
+            Object.entries(change).forEach(removeEmptyCounterparty);
+        });
+    });
+}
+function parseDeliveredAmount(tx) {
+    if (tx.TransactionType !== 'Payment' ||
+        tx.meta.TransactionResult !== 'tesSUCCESS') {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount && tx.meta.delivered_amount === 'unavailable') {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount) {
+        return (0, amount_1.default)(tx.meta.delivered_amount);
+    }
+    if (tx.meta.DeliveredAmount) {
+        return (0, amount_1.default)(tx.meta.DeliveredAmount);
+    }
+    if (tx.Amount && !(0, utils_1.isPartialPayment)(tx)) {
+        return (0, amount_1.default)(tx.Amount);
+    }
+    if (tx.Amount && tx.ledger_index > 4594094) {
+        return (0, amount_1.default)(tx.Amount);
+    }
+    return undefined;
+}
+function parseOutcome(tx) {
+    const metadata = tx.meta || tx.metaData;
+    if (!metadata) {
+        return undefined;
+    }
+    const balanceChanges = (0, transaction_1.parseBalanceChanges)(metadata);
+    const lockedBalanceChanges = (0, transaction_1.parseLockedBalanceChanges)(metadata);
+    const orderbookChanges = (0, transaction_1.parseOrderbookChanges)(metadata);
+    const channelChanges = (0, transaction_1.parseChannelChanges)(metadata);
+    const nftokenChanges = (0, transaction_1.parseNFTokenChanges)(tx);
+    const nftokenOfferChanges = (0, transaction_1.parseNFTokenOfferChanges)(tx);
+    const affectedObjects = (0, transaction_1.parseAffectedObjects)(tx);
+    removeEmptyCounterpartyInBalanceChanges(balanceChanges);
+    removeEmptyCounterpartyInBalanceChanges(lockedBalanceChanges);
+    removeEmptyCounterpartyInOrderbookChanges(orderbookChanges);
+    return (0, common_1.removeUndefined)({
+        result: tx.meta.TransactionResult,
+        timestamp: (0, utils_1.parseTimestamp)(tx.date),
+        fee: (0, common_1.dropsToXrp)(tx.Fee),
+        balanceChanges,
+        lockedBalanceChanges,
+        orderbookChanges,
+        channelChanges,
+        nftokenChanges,
+        nftokenOfferChanges,
+        affectedObjects: affectedObjects ? (0, common_1.removeUndefined)(affectedObjects) : undefined,
+        ledgerVersion: tx.ledger_index,
+        indexInLedger: tx.meta.TransactionIndex,
+        deliveredAmount: parseDeliveredAmount(tx)
+    });
+}
+exports.default = parseOutcome;

package/lib/v1/ledger/pathfind-types.d.ts

@@ -0,0 +1,59 @@
+import { Amount, RippledAmount, Adjustment, MaxAdjustment, MinAdjustment } from '../common/types/objects';
+export type LaxLaxAmount = {
+    currency: string;
+    value?: string;
+    issuer?: string;
+    counterparty?: string;
+};
+export type Path = {
+    source: Adjustment | MaxAdjustment;
+    destination: Adjustment | MinAdjustment;
+    paths: string;
+};
+export type GetPaths = Array<Path>;
+export type PathFind = {
+    source: {
+        address: string;
+        amount?: Amount;
+        currencies?: Array<{
+            currency: string;
+            counterparty?: string;
+        }>;
+    };
+    destination: {
+        address: string;
+        amount: LaxLaxAmount;
+    };
+};
+export type PathFindRequest = {
+    command: string;
+    source_account: string;
+    destination_amount: RippledAmount;
+    destination_account: string;
+    source_currencies?: {
+        currency: string;
+        issuer?: string;
+    }[];
+    send_max?: RippledAmount;
+};
+export type RippledPathsResponse = {
+    alternatives: Array<{
+        paths_computed: Array<Array<{
+            type: number;
+            type_hex: string;
+            account?: string;
+            issuer?: string;
+            currency?: string;
+        }>>;
+        source_amount: RippledAmount;
+    }>;
+    type: string;
+    destination_account: string;
+    destination_amount: RippledAmount;
+    destination_currencies?: Array<string>;
+    source_account: string;
+    source_currencies?: Array<{
+        currency: string;
+    }>;
+    full_reply?: boolean;
+};

package/lib/v1/ledger/pathfind-types.js

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

package/lib/v1/transaction/payment.d.ts

@@ -0,0 +1,14 @@
+import { TransactionJSON } from "./types";
+import { Adjustment, MaxAdjustment, MinAdjustment, FormattedMemo } from "../common/types/objects";
+export interface Payment {
+    source: Adjustment | MaxAdjustment;
+    destination: Adjustment | MinAdjustment;
+    paths?: string;
+    networkID?: number;
+    memos?: FormattedMemo[];
+    invoiceID?: string;
+    allowPartialPayment?: boolean;
+    noDirectRipple?: boolean;
+    limitQuality?: boolean;
+}
+export declare function createPaymentTransaction(address: string, paymentArgument: Payment): TransactionJSON;

package/lib/v1/transaction/payment.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPaymentTransaction = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const xrpl_1 = require("xrpl");
+const common_1 = require("../common");
+const common_2 = require("../../common");
+const utils_1 = require("./utils");
+function isMaxAdjustment(source) {
+    return source.maxAmount != null;
+}
+function isMinAdjustment(destination) {
+    return destination.minAmount != null;
+}
+function isXRPToXRPPayment(payment) {
+    const { source, destination } = payment;
+    const sourceCurrency = isMaxAdjustment(source) ? source.maxAmount.currency : source.amount.currency;
+    const destinationCurrency = isMinAdjustment(destination)
+        ? destination.minAmount.currency
+        : destination.amount.currency;
+    return ((sourceCurrency === "XRP" || sourceCurrency === "drops") &&
+        (destinationCurrency === "XRP" || destinationCurrency === "drops"));
+}
+function isIOUWithoutCounterparty(amount) {
+    return amount && amount.currency !== "XRP" && amount.currency !== "drops" && amount.counterparty == null;
+}
+function applyAnyCounterpartyEncoding(payment) {
+    [payment.source, payment.destination].forEach((adjustment) => {
+        ["amount", "minAmount", "maxAmount"].forEach((key) => {
+            if (isIOUWithoutCounterparty(adjustment[key])) {
+                adjustment[key].counterparty = adjustment.address;
+            }
+        });
+    });
+}
+function createMaximalAmount(amount) {
+    const maxXRPValue = "100000000000";
+    const maxIOUValue = "999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000";
+    let maxValue;
+    if (amount.currency === "XRP") {
+        maxValue = maxXRPValue;
+    }
+    else if (amount.currency === "drops") {
+        maxValue = (0, common_2.xrpToDrops)(maxXRPValue);
+    }
+    else {
+        maxValue = maxIOUValue;
+    }
+    return Object.assign({}, amount, { value: maxValue });
+}
+function validateAndNormalizeAddress(address, expectedTag) {
+    const classicAddress = (0, utils_1.getClassicAccountAndTag)(address, expectedTag);
+    classicAddress.tag = classicAddress.tag === false ? undefined : classicAddress.tag;
+    return classicAddress;
+}
+function createPaymentTransaction(address, paymentArgument) {
+    const payment = lodash_1.default.cloneDeep(paymentArgument);
+    applyAnyCounterpartyEncoding(payment);
+    const sourceAddressAndTag = validateAndNormalizeAddress(payment.source.address, payment.source.tag);
+    const addressToVerifyAgainst = validateAndNormalizeAddress(address, undefined);
+    if (addressToVerifyAgainst.classicAccount !== sourceAddressAndTag.classicAccount) {
+        throw new Error("address must match payment.source.address");
+    }
+    if (addressToVerifyAgainst.tag != null &&
+        sourceAddressAndTag.tag != null &&
+        addressToVerifyAgainst.tag !== sourceAddressAndTag.tag) {
+        throw new Error("address includes a tag that does not match payment.source.tag");
+    }
+    const destinationAddressAndTag = validateAndNormalizeAddress(payment.destination.address, payment.destination.tag);
+    if ((isMaxAdjustment(payment.source) && isMinAdjustment(payment.destination)) ||
+        (!isMaxAdjustment(payment.source) && !isMinAdjustment(payment.destination))) {
+        throw new Error("payment must specify either (source.maxAmount " +
+            "and destination.amount) or (source.amount and destination.minAmount)");
+    }
+    const destinationAmount = isMinAdjustment(payment.destination)
+        ? payment.destination.minAmount
+        : payment.destination.amount;
+    const sourceAmount = isMaxAdjustment(payment.source) ? payment.source.maxAmount : payment.source.amount;
+    const amount = isMinAdjustment(payment.destination) && !isXRPToXRPPayment(payment)
+        ? createMaximalAmount(destinationAmount)
+        : destinationAmount;
+    const txJSON = {
+        TransactionType: "Payment",
+        Account: sourceAddressAndTag.classicAccount,
+        Destination: destinationAddressAndTag.classicAccount,
+        Amount: (0, common_1.toRippledAmount)(amount),
+        Flags: 0,
+    };
+    if (payment.invoiceID != null) {
+        txJSON.InvoiceID = payment.invoiceID;
+    }
+    if (sourceAddressAndTag.tag != null) {
+        txJSON.SourceTag = sourceAddressAndTag.tag;
+    }
+    if (destinationAddressAndTag.tag != null) {
+        txJSON.DestinationTag = destinationAddressAndTag.tag;
+    }
+    if (payment.networkID != null) {
+        txJSON.NetworkID = payment.networkID;
+    }
+    if (payment.memos != null) {
+        txJSON.Memos = payment.memos.map(utils_1.convertMemo);
+    }
+    if (payment.noDirectRipple === true) {
+        txJSON.Flags |= xrpl_1.PaymentFlags.tfNoDirectRipple;
+    }
+    if (payment.limitQuality === true) {
+        txJSON.Flags |= xrpl_1.PaymentFlags.tfLimitQuality;
+    }
+    if (!isXRPToXRPPayment(payment)) {
+        if (payment.allowPartialPayment || isMinAdjustment(payment.destination)) {
+            txJSON.Flags |= xrpl_1.PaymentFlags.tfPartialPayment;
+        }
+        txJSON.SendMax = (0, common_1.toRippledAmount)(sourceAmount);
+        if (isMinAdjustment(payment.destination)) {
+            txJSON.DeliverMin = (0, common_1.toRippledAmount)(destinationAmount);
+        }
+        if (payment.paths != null) {
+            txJSON.Paths = JSON.parse(payment.paths);
+        }
+    }
+    else if (payment.allowPartialPayment === true) {
+        throw new Error("XRP to XRP payments cannot be partial payments");
+    }
+    return txJSON;
+}
+exports.createPaymentTransaction = createPaymentTransaction;