@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/ledger/vl.js

@@ -0,0 +1,131 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVL = createVL;
+exports.createVLBlob = createVLBlob;
+exports.getVLBlobValidatorsManifest = getVLBlobValidatorsManifest;
+const ripple_address_codec_1 = require("ripple-address-codec");
+const Client = __importStar(require("../client"));
+const utils_1 = require("../parse/utils");
+const vl_1 = require("../models/vl");
+const manifest_1 = require("../models/manifest");
+const ledger_1 = require("../models/ledger");
+const Validator = __importStar(require("../validator"));
+async function createVL(masterKey, ephemeralKey, sequence, expiration, validatorsPublicKeys) {
+    if (!masterKey) {
+        throw new Error("Master key is required");
+    }
+    if (!ephemeralKey) {
+        throw new Error("Ephemeral key is required");
+    }
+    if (masterKey.publicKey === ephemeralKey.publicKey) {
+        throw new Error("Master and ephemeral keys must be different.");
+    }
+    if (typeof sequence !== "number") {
+        throw new Error("sequence must be a number.");
+    }
+    if (typeof expiration !== "number") {
+        throw new Error("expiration must be a number.");
+    }
+    if (Array.isArray(validatorsPublicKeys) === false) {
+        throw new Error("validatorsPublicKeys must be an array.");
+    }
+    if (validatorsPublicKeys.length === 0) {
+        throw new Error("validatorsPublicKeys must not be empty.");
+    }
+    for (const publicKey of validatorsPublicKeys) {
+        if (typeof publicKey !== "string") {
+            throw new Error("validatorsPublicKeys must be an array of strings.");
+        }
+        if (publicKey[0] !== "n") {
+            throw new Error("validatorsPublicKeys must be an array of strings starting with 'n'.");
+        }
+    }
+    const vlBlob = await createVLBlob(sequence, expiration, validatorsPublicKeys);
+    const blob = (0, vl_1.encodeVLBlob)(vlBlob);
+    const manifest = (0, manifest_1.generateManifest)({
+        Sequence: sequence,
+        PublicKey: masterKey.publicKey,
+        SigningPubKey: ephemeralKey.publicKey,
+        SigningPrivateKey: ephemeralKey.privateKey,
+        MasterPrivateKey: masterKey.privateKey,
+    });
+    const signature = Validator.sign(Buffer.from(blob, "base64"), ephemeralKey.privateKey);
+    return {
+        blob,
+        manifest,
+        signature,
+        public_key: masterKey.publicKey,
+        version: 1,
+    };
+}
+async function createVLBlob(sequence, expiration, validatorsPublicKeys) {
+    const validators = await getVLBlobValidatorsManifest(validatorsPublicKeys);
+    return {
+        sequence,
+        expiration: (0, ledger_1.unixTimeToLedgerTime)(expiration),
+        validators,
+    };
+}
+async function getVLBlobValidatorsManifest(validatorsPublicKeys) {
+    const connection = Client.findConnection("manifest");
+    if (!connection) {
+        throw new Error("There is no connection");
+    }
+    const validatorsManifests = await Promise.all(validatorsPublicKeys.map(async (publicKey) => {
+        const response = await connection.request({
+            command: "manifest",
+            public_key: publicKey,
+        });
+        if (response.error) {
+            Promise.reject(response.error);
+        }
+        if (!response.result || !response.result.manifest) {
+            return Promise.reject(new Error("Failed to get validator manifest"));
+        }
+        return response.result;
+    }));
+    const validators = validatorsManifests.map((info) => {
+        const validationPublicKey = info.requested;
+        const publicKeyBuffer = (0, ripple_address_codec_1.decodeNodePublic)(validationPublicKey);
+        const publicKey = (0, utils_1.bytesToHex)(publicKeyBuffer.buffer);
+        const manifest = info.manifest;
+        return {
+            validation_public_key: publicKey,
+            manifest,
+        };
+    });
+    return validators;
+}

package/lib/src/models/account_info.d.ts

@@ -0,0 +1,184 @@
+import { LedgerEntry, AccountSetAsfFlags } from "xrpl";
+import { QueueData } from "../types/queue_data";
+export declare enum XahauAccountRootFlags {
+    lsfTshCollect = 33554432,
+    lsfURITokenIssuer = 1073741824,
+    lsfDisallowIncomingRemit = 2147483648
+}
+export declare const AccountRootFlagsKeys: {
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export declare const XRPLAccountRootFlagsKeys: {
+    allowTrustLineClawback: LedgerEntry.AccountRootFlags;
+    allowTrustLineLocking: LedgerEntry.AccountRootFlags;
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export declare const XahauAccountRootFlagsKeys: {
+    tshCollect: XahauAccountRootFlags;
+    uriTokenIssuer: XahauAccountRootFlags;
+    disallowIncomingRemit: XahauAccountRootFlags;
+    passwordSpent: LedgerEntry.AccountRootFlags;
+    requireDestTag: LedgerEntry.AccountRootFlags;
+    requireAuth: LedgerEntry.AccountRootFlags;
+    depositAuth: LedgerEntry.AccountRootFlags;
+    disallowXRP: LedgerEntry.AccountRootFlags;
+    disableMaster: LedgerEntry.AccountRootFlags;
+    noFreeze: LedgerEntry.AccountRootFlags;
+    globalFreeze: LedgerEntry.AccountRootFlags;
+    defaultRipple: LedgerEntry.AccountRootFlags;
+    disallowIncomingNFTokenOffer: LedgerEntry.AccountRootFlags;
+    disallowIncomingCheck: LedgerEntry.AccountRootFlags;
+    disallowIncomingPayChan: LedgerEntry.AccountRootFlags;
+    disallowIncomingTrustline: LedgerEntry.AccountRootFlags;
+};
+export declare function getAccountRootFlagsKeys(): Record<string, number>;
+export interface AccountRootFlagsKeysInterface {
+    passwordSpent?: boolean;
+    requireDestTag?: boolean;
+    requireAuth?: boolean;
+    depositAuth?: boolean;
+    disallowXRP?: boolean;
+    disableMaster?: boolean;
+    noFreeze?: boolean;
+    globalFreeze?: boolean;
+    defaultRipple?: boolean;
+    disallowIncomingNFTokenOffer?: boolean;
+    disallowIncomingCheck?: boolean;
+    disallowIncomingPayChan?: boolean;
+    disallowIncomingTrustline?: boolean;
+    enableTransactionIDTracking?: boolean;
+    allowTrustLineClawback?: boolean;
+    allowTrustLineLocking?: boolean;
+    tshCollect?: boolean;
+    uriTokenIssuer?: boolean;
+    disallowIncomingRemit?: boolean;
+}
+export declare enum XahauAccountSetAsfFlags {
+    asfTshCollect = 11,
+    asfDisallowIncomingRemit = 16
+}
+export declare const AccountSetFlags: {
+    requireDestinationTag: AccountSetAsfFlags;
+    requireAuthorization: AccountSetAsfFlags;
+    depositAuth: AccountSetAsfFlags;
+    disallowIncomingXRP: AccountSetAsfFlags;
+    disableMasterKey: AccountSetAsfFlags;
+    enableTransactionIDTracking: AccountSetAsfFlags;
+    noFreeze: AccountSetAsfFlags;
+    globalFreeze: AccountSetAsfFlags;
+    defaultRipple: AccountSetAsfFlags;
+    authorizedMinter: AccountSetAsfFlags;
+    disallowIncomingNFTokenOffer: AccountSetAsfFlags;
+    disallowIncomingCheck: AccountSetAsfFlags;
+    disallowIncomingPayChan: AccountSetAsfFlags;
+    disallowIncomingTrustline: AccountSetAsfFlags;
+    allowTrustLineClawback: AccountSetAsfFlags;
+    allowTrustLineLocking: AccountSetAsfFlags;
+    tshCollect: XahauAccountSetAsfFlags;
+    disallowIncomingRemit: XahauAccountSetAsfFlags;
+};
+export declare const SignerListFlagsKeys: {
+    oneOwnerCount: LedgerEntry.SignerListFlags;
+};
+export interface SignerListFlagsKeysInterface {
+    oneOwnerCount?: boolean;
+}
+export interface AccountFieldParametersInterface {
+    name: string;
+    encoding?: string;
+    length?: number;
+    defaults?: any;
+    shift?: number;
+}
+export declare const AccountFields: {
+    EmailHash: {
+        name: string;
+        encoding: string;
+        length: number;
+        defaults: string;
+    };
+    MessageKey: {
+        name: string;
+    };
+    Domain: {
+        name: string;
+        encoding: string;
+    };
+    TransferRate: {
+        name: string;
+        defaults: number;
+        shift: number;
+    };
+    TickSize: {
+        name: string;
+        defaults: number;
+    };
+    RegularKey: {
+        name: string;
+    };
+    NFTokenMinter: {
+        name: string;
+    };
+    WalletLocator: {
+        name: string;
+    };
+};
+export interface AccountInfoResponse extends AccountSignerListResponse {
+    account_data: AccountInfoDataResponse;
+    ledger_current_index?: number;
+    ledger_index?: number;
+    queue_data?: QueueData;
+    validated?: boolean;
+}
+export interface AccountSignerListResponse {
+    signer_lists?: LedgerEntry.SignerList[];
+}
+export interface AccountInfoDataResponse extends LedgerEntry.AccountRoot, AccountSignerListResponse {
+}
+export interface AccountFieldsInterface {
+    blackholed?: boolean;
+    emailHash?: string;
+    messageKey?: string;
+    domain?: string;
+    transferRate?: number;
+    tickSize?: number;
+    regularKey?: string;
+    nftokenMinter?: string;
+    walletLocator?: string;
+}
+export interface AccountSettingsInterface extends AccountFieldsInterface, AccountRootFlagsKeysInterface {
+}
+export declare function getSettings(accountInfo: AccountInfoDataResponse, excludeFalse?: boolean): AccountSettingsInterface;
+export declare function parseAccountFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): AccountRootFlagsKeysInterface;
+export declare function parseAccountFields(accountInfo: AccountInfoDataResponse, options?: {
+    excludeFalse?: boolean;
+}): AccountFieldsInterface;
+export declare function parseSignerListFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): SignerListFlagsKeysInterface;

package/lib/src/models/account_info.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountFields = exports.SignerListFlagsKeys = exports.AccountSetFlags = exports.XahauAccountSetAsfFlags = exports.XahauAccountRootFlagsKeys = exports.XRPLAccountRootFlagsKeys = exports.AccountRootFlagsKeys = exports.XahauAccountRootFlags = void 0;
+exports.getAccountRootFlagsKeys = getAccountRootFlagsKeys;
+exports.getSettings = getSettings;
+exports.parseAccountFlags = parseAccountFlags;
+exports.parseAccountFields = parseAccountFields;
+exports.parseSignerListFlags = parseSignerListFlags;
+const xrpl_1 = require("xrpl");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const common_1 = require("../common");
+const flags_1 = require("../parse/ledger/flags");
+const client_1 = require("../client");
+var XahauAccountRootFlags;
+(function (XahauAccountRootFlags) {
+    XahauAccountRootFlags[XahauAccountRootFlags["lsfTshCollect"] = 33554432] = "lsfTshCollect";
+    XahauAccountRootFlags[XahauAccountRootFlags["lsfURITokenIssuer"] = 1073741824] = "lsfURITokenIssuer";
+    XahauAccountRootFlags[XahauAccountRootFlags["lsfDisallowIncomingRemit"] = 2147483648] = "lsfDisallowIncomingRemit";
+})(XahauAccountRootFlags || (exports.XahauAccountRootFlags = XahauAccountRootFlags = {}));
+exports.AccountRootFlagsKeys = {
+    passwordSpent: xrpl_1.LedgerEntry.AccountRootFlags.lsfPasswordSpent,
+    requireDestTag: xrpl_1.LedgerEntry.AccountRootFlags.lsfRequireDestTag,
+    requireAuth: xrpl_1.LedgerEntry.AccountRootFlags.lsfRequireAuth,
+    depositAuth: xrpl_1.LedgerEntry.AccountRootFlags.lsfDepositAuth,
+    disallowXRP: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowXRP,
+    disableMaster: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisableMaster,
+    noFreeze: xrpl_1.LedgerEntry.AccountRootFlags.lsfNoFreeze,
+    globalFreeze: xrpl_1.LedgerEntry.AccountRootFlags.lsfGlobalFreeze,
+    defaultRipple: xrpl_1.LedgerEntry.AccountRootFlags.lsfDefaultRipple,
+    disallowIncomingNFTokenOffer: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingNFTokenOffer,
+    disallowIncomingCheck: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingCheck,
+    disallowIncomingPayChan: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingPayChan,
+    disallowIncomingTrustline: xrpl_1.LedgerEntry.AccountRootFlags.lsfDisallowIncomingTrustline,
+};
+exports.XRPLAccountRootFlagsKeys = {
+    ...exports.AccountRootFlagsKeys,
+    allowTrustLineClawback: xrpl_1.LedgerEntry.AccountRootFlags.lsfAllowTrustLineClawback,
+    allowTrustLineLocking: xrpl_1.LedgerEntry.AccountRootFlags.lsfAllowTrustLineLocking,
+};
+exports.XahauAccountRootFlagsKeys = {
+    ...exports.AccountRootFlagsKeys,
+    tshCollect: XahauAccountRootFlags.lsfTshCollect,
+    uriTokenIssuer: XahauAccountRootFlags.lsfURITokenIssuer,
+    disallowIncomingRemit: XahauAccountRootFlags.lsfDisallowIncomingRemit,
+};
+function getAccountRootFlagsKeys() {
+    const nativeCurrency = (0, client_1.getNativeCurrency)();
+    if (nativeCurrency === common_1.XAHAU_NATIVE_CURRENCY) {
+        return exports.XahauAccountRootFlagsKeys;
+    }
+    else {
+        return exports.XRPLAccountRootFlagsKeys;
+    }
+}
+var XahauAccountSetAsfFlags;
+(function (XahauAccountSetAsfFlags) {
+    XahauAccountSetAsfFlags[XahauAccountSetAsfFlags["asfTshCollect"] = 11] = "asfTshCollect";
+    XahauAccountSetAsfFlags[XahauAccountSetAsfFlags["asfDisallowIncomingRemit"] = 16] = "asfDisallowIncomingRemit";
+})(XahauAccountSetAsfFlags || (exports.XahauAccountSetAsfFlags = XahauAccountSetAsfFlags = {}));
+exports.AccountSetFlags = {
+    requireDestinationTag: xrpl_1.AccountSetAsfFlags.asfRequireDest,
+    requireAuthorization: xrpl_1.AccountSetAsfFlags.asfRequireAuth,
+    depositAuth: xrpl_1.AccountSetAsfFlags.asfDepositAuth,
+    disallowIncomingXRP: xrpl_1.AccountSetAsfFlags.asfDisallowXRP,
+    disableMasterKey: xrpl_1.AccountSetAsfFlags.asfDisableMaster,
+    enableTransactionIDTracking: xrpl_1.AccountSetAsfFlags.asfAccountTxnID,
+    noFreeze: xrpl_1.AccountSetAsfFlags.asfNoFreeze,
+    globalFreeze: xrpl_1.AccountSetAsfFlags.asfGlobalFreeze,
+    defaultRipple: xrpl_1.AccountSetAsfFlags.asfDefaultRipple,
+    authorizedMinter: xrpl_1.AccountSetAsfFlags.asfAuthorizedNFTokenMinter,
+    disallowIncomingNFTokenOffer: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingNFTokenOffer,
+    disallowIncomingCheck: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingCheck,
+    disallowIncomingPayChan: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingPayChan,
+    disallowIncomingTrustline: xrpl_1.AccountSetAsfFlags.asfDisallowIncomingTrustline,
+    allowTrustLineClawback: xrpl_1.AccountSetAsfFlags.asfAllowTrustLineClawback,
+    allowTrustLineLocking: xrpl_1.AccountSetAsfFlags.asfAllowTrustLineLocking,
+    tshCollect: XahauAccountSetAsfFlags.asfTshCollect,
+    disallowIncomingRemit: XahauAccountSetAsfFlags.asfDisallowIncomingRemit,
+};
+exports.SignerListFlagsKeys = {
+    oneOwnerCount: xrpl_1.LedgerEntry.SignerListFlags.lsfOneOwnerCount,
+};
+exports.AccountFields = {
+    EmailHash: { name: "emailHash", encoding: "hex", length: 32, defaults: "00000000000000000000000000000000" },
+    MessageKey: { name: "messageKey" },
+    Domain: { name: "domain", encoding: "hex" },
+    TransferRate: { name: "transferRate", defaults: 0, shift: 9 },
+    TickSize: { name: "tickSize", defaults: 0 },
+    RegularKey: { name: "regularKey" },
+    NFTokenMinter: { name: "nftokenMinter" },
+    WalletLocator: { name: "walletLocator" },
+};
+function getSettings(accountInfo, excludeFalse = true) {
+    const parsedFlags = parseAccountFlags(accountInfo.Flags, { excludeFalse });
+    const parsedFields = parseAccountFields(accountInfo, { excludeFalse });
+    return {
+        ...parsedFlags,
+        ...parsedFields,
+    };
+}
+function parseAccountFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, getAccountRootFlagsKeys(), options);
+}
+function parseAccountFields(accountInfo, options = {}) {
+    const settings = {};
+    if (accountInfo.hasOwnProperty("signer_lists")) {
+        if (accountInfo.Flags & exports.AccountRootFlagsKeys.disableMaster &&
+            common_1.BLACKHOLE_ACCOUNTS.includes(accountInfo.RegularKey) &&
+            accountInfo.signer_lists?.length === 0) {
+            settings.blackholed = true;
+        }
+        else if (!options.excludeFalse) {
+            settings.blackholed = false;
+        }
+    }
+    for (const fieldName in exports.AccountFields) {
+        const fieldValue = accountInfo[fieldName];
+        if (fieldValue != null) {
+            const info = exports.AccountFields[fieldName];
+            settings[info.name] = parseField(info, fieldValue);
+        }
+    }
+    function parseField(info, value) {
+        if (info.encoding === "hex" && !info.length) {
+            return Buffer.from(value, "hex").toString("ascii");
+        }
+        if (info.shift) {
+            return new bignumber_js_1.default(value).shiftedBy(-info.shift).toNumber();
+        }
+        return value;
+    }
+    return settings;
+}
+function parseSignerListFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, exports.SignerListFlagsKeys, options);
+}

package/lib/src/models/account_lines.d.ts

@@ -0,0 +1,26 @@
+export interface Trustline {
+    account: string;
+    balance: string;
+    currency: string;
+    limit: string;
+    limit_peer: string;
+    lock_count?: number;
+    locked_balance?: string;
+    quality_in: number;
+    quality_out: number;
+    no_ripple?: boolean;
+    no_ripple_peer?: boolean;
+    authorized?: boolean;
+    peer_authorized?: boolean;
+    freeze?: boolean;
+    freeze_peer?: boolean;
+}
+export interface AccountLinesResponse {
+    account: string;
+    lines: Trustline[];
+    ledger_current_index?: number;
+    ledger_index?: number;
+    ledger_hash?: string;
+    marker?: unknown;
+    validated?: boolean;
+}

package/lib/src/models/account_lines.js

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

package/lib/src/models/account_namespace.d.ts

@@ -0,0 +1,16 @@
+export interface HookNamespaceEntry {
+    Flags: number;
+    LedgerEntryType: string;
+    HookStateData: string;
+    HookStateKey: string;
+    OwnerNode: string;
+    index: string;
+}
+export interface HookNamespaceResponse {
+    account: string;
+    namespace_entries: HookNamespaceEntry[];
+    ledger_current_index?: number;
+    ledger_index?: number;
+    namespace_id?: string;
+    validated?: boolean;
+}

package/lib/src/models/account_namespace.js

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

package/lib/src/models/account_nfts.d.ts

@@ -0,0 +1,20 @@
+import { SortDirection } from "../common";
+export interface NFTokenInterface {
+    Flags: number;
+    Issuer: string;
+    NFTokenID: string;
+    NFTokenTaxon: number;
+    TransferFee: number;
+    Sequence: number;
+}
+export interface AccountNFTokenInterface {
+    Flags: number;
+    Issuer: string;
+    NFTokenID: string;
+    TokenTaxons: number;
+    nft_serial: number;
+}
+export declare function sortHelperAccountNFToken(a: AccountNFTokenInterface, b: AccountNFTokenInterface): SortDirection;
+export declare function cipheredTaxon(tokenSeq: number, taxon: number): number;
+export declare function parseNFTokenID(nftokenID: string): NFTokenInterface | null;
+export declare function buildNFTokenID(flags: number, transferFee: number, issuer: string, taxon: number, sequence: number): string;

package/lib/src/models/account_nfts.js

@@ -0,0 +1,92 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.sortHelperAccountNFToken = sortHelperAccountNFToken;
+exports.cipheredTaxon = cipheredTaxon;
+exports.parseNFTokenID = parseNFTokenID;
+exports.buildNFTokenID = buildNFTokenID;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const AddressCodec = __importStar(require("ripple-address-codec"));
+const utils_1 = require("../parse/utils");
+function sortHelperAccountNFToken(a, b) {
+    const cmpIssuer = a.Issuer.localeCompare(b.Issuer);
+    if (cmpIssuer !== 0) {
+        return cmpIssuer;
+    }
+    if (a.nft_serial < b.nft_serial) {
+        return -1;
+    }
+    if (a.nft_serial > b.nft_serial) {
+        return 1;
+    }
+    return 0;
+}
+function cipheredTaxon(tokenSeq, taxon) {
+    const m = 384160001n;
+    const c = 2459n;
+    const max = 4294967296n;
+    const p1 = (m * BigInt(tokenSeq)) % max;
+    const p2 = (p1 + c) % max;
+    return (taxon ^ Number(p2)) >>> 0;
+}
+function parseNFTokenID(nftokenID) {
+    if (typeof nftokenID !== "string" || nftokenID.length !== 64) {
+        return null;
+    }
+    const flags = new bignumber_js_1.default(nftokenID.slice(0, 4), 16).toNumber();
+    const transferFee = new bignumber_js_1.default(nftokenID.slice(4, 8), 16).toNumber();
+    const issuer = AddressCodec.encodeAccountID(Buffer.from(nftokenID.slice(8, 48), "hex"));
+    const scrambledTaxon = new bignumber_js_1.default(nftokenID.slice(48, 56), 16).toNumber();
+    const sequence = new bignumber_js_1.default(nftokenID.slice(56, 64), 16).toNumber();
+    return {
+        NFTokenID: nftokenID,
+        Flags: flags,
+        TransferFee: transferFee,
+        Issuer: issuer,
+        NFTokenTaxon: cipheredTaxon(sequence, scrambledTaxon),
+        Sequence: sequence,
+    };
+}
+function buildNFTokenID(flags, transferFee, issuer, taxon, sequence) {
+    const scrambledTaxon = cipheredTaxon(sequence, taxon);
+    return (new bignumber_js_1.default(flags).toString(16).padStart(4, "0").toUpperCase() +
+        new bignumber_js_1.default(transferFee).toString(16).padStart(4, "0").toUpperCase() +
+        (0, utils_1.bytesToHex)(AddressCodec.decodeAccountID(issuer).buffer) +
+        new bignumber_js_1.default(scrambledTaxon).toString(16).padStart(8, "0").toUpperCase() +
+        new bignumber_js_1.default(sequence).toString(16).padStart(8, "0").toUpperCase());
+}

package/lib/src/models/account_object.d.ts

@@ -0,0 +1,61 @@
+import { LedgerEntry } from "xrpl";
+import { Trustline } from "./account_lines";
+import { Amount } from "../types";
+export type AccountObject = LedgerEntry.Check | LedgerEntry.DepositPreauth | LedgerEntry.Escrow | LedgerEntry.Offer | LedgerEntry.PayChannel | LedgerEntry.SignerList | LedgerEntry.Ticket | LedgerEntry.RippleState;
+export type AccountObjectType = Exclude<LedgerEntry.LedgerEntryFilter, "amendments" | "fee" | "hashes"> | "uri_token";
+export interface AccountObjects {
+    account: string;
+    account_objects: AccountObject[];
+    ledger_hash?: string;
+    ledger_index?: number;
+    ledger_current_index?: number;
+    limit?: number;
+    marker?: string;
+    validated?: boolean;
+}
+export interface AccountNFTObjectsResponse {
+    account: string;
+    nft_offers: AccountNFTOffersInterface[];
+    ledger_hash?: string;
+    ledger_index?: number;
+    ledger_current_index?: number;
+    limit?: number;
+    marker?: string;
+    validated?: boolean;
+}
+export interface AccountNFTOffersInterface {
+    nft_id: string;
+    amount: Amount;
+    flags: number;
+    index: string;
+    owner: string;
+    destination?: string;
+    expiration?: number;
+    ledger_index: number;
+    transaction_hash: string;
+}
+export interface AccountURITokensInterface {
+    flags: number;
+    index: string;
+    owner: string;
+    issuer: string;
+    uri: number;
+    digest?: string;
+    amount?: Amount;
+    destination?: string;
+    ledger_index: number;
+    transaction_hash: string;
+}
+export interface AccountURITokensObjectsResponse {
+    account: string;
+    uritokens: AccountURITokensInterface[];
+    ledger_hash?: string;
+    ledger_index?: number;
+    ledger_current_index?: number;
+    limit?: number;
+    marker?: string;
+    validated?: boolean;
+}
+export declare function accountObjectsToAccountLines(account: string, accountObjects: AccountObject[]): Trustline[];
+export declare function accountObjectsToNFTOffers(accountObjects: AccountObject[]): AccountNFTOffersInterface[];
+export declare function accountObjectsToURITokens(accountObjects: AccountObject[]): AccountURITokensInterface[];