@bitgo-beta/sdk-coin-xrp 1.3.3-alpha.43 → 1.3.3-alpha.430

package/dist/src/lib/transferBuilder.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    get xrpTransactionType() {
+        return 'Payment';
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const { destination, amount, destinationTag } = tx.toJson();
+        if (!destination) {
+            throw new sdk_core_1.BuildTransactionError('Missing destination');
+        }
+        if (!amount) {
+            throw new sdk_core_1.BuildTransactionError('Missing amount');
+        }
+        const normalizeAddress = utils_1.default.normalizeAddress({ address: destination, destinationTag });
+        this.to(normalizeAddress);
+        if (typeof amount !== 'string') {
+            throw new sdk_core_1.BuildTransactionError('Invalid Amount');
+        }
+        this.amount(amount);
+    }
+    /**
+     *  Set the receiver address
+     * @param {string} address - the address with optional destination tag
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    to(address) {
+        const { address: xrpAddress, destinationTag } = utils_1.default.getAddressDetails(address);
+        this._destination = xrpAddress;
+        this._destinationTag = destinationTag;
+        return this;
+    }
+    /**
+     *  Set the amount to send
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    amount(amount) {
+        if (typeof amount !== 'string') {
+            throw new Error(`amount type ${typeof amount} must be a string`);
+        }
+        const amountBigInt = BigInt(amount);
+        if (amountBigInt < 0) {
+            throw new Error(`amount ${amount} is not valid`);
+        }
+        this._amount = amount;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        if (!this._sender) {
+            throw new sdk_core_1.BuildTransactionError('Sender must be set before building the transaction');
+        }
+        const transferFields = {
+            TransactionType: this.xrpTransactionType,
+            Account: this._sender,
+            Destination: this._destination,
+            Amount: this._amount,
+        };
+        if (typeof this._destinationTag === 'number') {
+            transferFields.DestinationTag = this._destinationTag;
+        }
+        this._specificFields = transferFields;
+        return await super.buildImplementation();
+    }
+}
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/trustsetBuilder.d.ts

@@ -0,0 +1,21 @@
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { XrpTransactionType } from './iface';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class TrustSetBuilder extends TransactionBuilder {
+    private _amount;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    protected get xrpTransactionType(): XrpTransactionType.TrustSet;
+    initBuilder(tx: Transaction): void;
+    /**
+     *  Set the amount to send
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    amount(amount: string): TransactionBuilder;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=trustsetBuilder.d.ts.map

package/dist/src/lib/trustsetBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trustsetBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/trustsetBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD,OAAO,CAAC,OAAO,CAAuB;gBAE1B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,SAAS,KAAK,kBAAkB,IAAI,kBAAkB,CAAC,QAAQ,CAE9D;IAED,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAelC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB;IAkB1C,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAe5D"}

package/dist/src/lib/trustsetBuilder.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustSetBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class TrustSetBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.TrustLine;
+    }
+    get xrpTransactionType() {
+        return iface_1.XrpTransactionType.TrustSet;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const { amount } = tx.toJson();
+        if (!amount) {
+            throw new sdk_core_1.BuildTransactionError('Missing amount');
+        }
+        if (!utils_1.default.isIssuedCurrencyAmount(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid Limit Amount');
+        }
+        // The amount is represented in decimal notation, so we need to multiply it by the decimal places
+        const amountBigNum = (0, bignumber_js_1.default)(amount.value).shiftedBy(this._coinConfig.decimalPlaces);
+        this.amount(amountBigNum.toFixed());
+    }
+    /**
+     *  Set the amount to send
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    amount(amount) {
+        if (typeof amount !== 'string') {
+            throw new Error(`amount type ${typeof amount} must be a string`);
+        }
+        const amountBigNum = (0, bignumber_js_1.default)(amount);
+        if (amountBigNum.lt(0)) {
+            throw new Error(`amount ${amount} is not valid`);
+        }
+        const currency = utils_1.default.getXrpCurrencyFromTokenName(this._coinConfig.name);
+        // Unlike most coins, XRP Token amounts are represented in decimal notation
+        const value = amountBigNum.shiftedBy(-1 * this._coinConfig.decimalPlaces).toFixed();
+        this._amount = {
+            value: value,
+            ...currency,
+        };
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        if (!this._sender) {
+            throw new sdk_core_1.BuildTransactionError('Sender must be set before building the transaction');
+        }
+        const trustSetFields = {
+            TransactionType: this.xrpTransactionType,
+            Account: this._sender,
+            LimitAmount: this._amount,
+        };
+        this._specificFields = trustSetFields;
+        return await super.buildImplementation();
+    }
+}
+exports.TrustSetBuilder = TrustSetBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/utils.d.ts

@@ -0,0 +1,78 @@
+import { BaseUtils } from '@bitgo-beta/sdk-core';
+import { BaseCoin } from '@bitgo-beta/statics';
+import * as xrpl from 'xrpl';
+import { Amount, IssuedCurrencyAmount } from 'xrpl';
+import { Address, SignerDetails } from './iface';
+declare class Utils implements BaseUtils {
+    isValidAddress(address: string): boolean;
+    isValidTransactionId(txId: string): boolean;
+    isValidPublicKey(key: string): boolean;
+    isValidPrivateKey(key: string): boolean;
+    isValidSignature(signature: string): boolean;
+    isValidBlockId(hash: string): boolean;
+    isValidHex(hex: string): boolean;
+    /**
+     * Parse an address string into address and destination tag
+     */
+    getAddressDetails(address: string): Address;
+    /**
+     * Construct a full, normalized address from an address and destination tag
+     */
+    normalizeAddress({ address, destinationTag }: Address): string;
+    /**
+     * @param message hex encoded string
+     * @param privateKey
+     * return hex encoded signature string, throws if any of the inputs are invalid
+     */
+    signString(message: string, privateKey: string): string;
+    /**
+     * @param message hex encoded string
+     * @param signature hex encooded signature string
+     * @param publicKey
+     * return boolean, throws if any of the inputs are invalid
+     */
+    verifySignature(message: string, signature: string, publicKey: string): boolean;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {string} rawTransaction - Transaction in hex string format
+     */
+    validateRawTransaction(rawTransaction: string): void;
+    /**
+     * Checks if raw transaction can be deserialized
+     *
+     * @param {string} rawTransaction - transaction in base64 string format
+     * @returns {boolean} - the validation result
+     */
+    isValidRawTransaction(rawTransaction: string): boolean;
+    validateAccountSetFlag(setFlag: number): void;
+    validateSigner(signer: SignerDetails): void;
+    /**
+     * Determines if the provided `amount` is for a token payment
+     */
+    isIssuedCurrencyAmount(amount: Amount): amount is IssuedCurrencyAmount;
+    /**
+     * Get the associated XRP Currency details from token name. Throws an error if token is unsupported
+     * @param {string} tokenName - The token name
+     */
+    getXrpCurrencyFromTokenName(tokenName: string): xrpl.IssuedCurrency;
+    /**
+     * Decodes a serialized XRPL transaction.
+     *
+     * @param {string} txHex - The serialized transaction in hex.
+     * @returns {Object} - Decoded transaction object.
+     * @throws {Error} - If decoding fails or input is invalid.
+     */
+    decodeTransaction(txHex: string): Record<string, unknown>;
+    /**
+     * Get the statics coin object matching a given Xrp token issuer address and currency code if it exists
+     *
+     * @param issuerAddress The token issuer address to match against
+     * @param currencyCode The token currency code to match against
+     * @returns statics BaseCoin object for the matching token
+     */
+    getXrpToken(issuerAddress: any, currencyCode: any): Readonly<BaseCoin> | undefined;
+}
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAkB,MAAM,qBAAqB,CAAC;AAI/D,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAEpD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIjD,cAAM,KAAM,YAAW,SAAS;IAC9B,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IASxC,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAStC,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IASvC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC;;OAEG;IACI,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IA8ClD;;OAEG;IACI,gBAAgB,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,OAAO,GAAG,MAAM;IAgBrE;;;;OAIG;IACI,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAU9D;;;;;OAKG;IACI,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAiBtF;;;;OAIG;IACI,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAY3D;;;;;OAKG;IACI,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAUtD,sBAAsB,CAAC,OAAO,EAAE,MAAM;IAStC,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAYlD;;OAEG;IACI,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,oBAAoB;IAU7E;;;OAGG;IACI,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc;IAc1E;;;;;;OAMG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM;IAWtC;;;;;;OAMG;IACI,WAAW,CAAC,aAAa,KAAA,EAAE,YAAY,KAAA,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,SAAS;CAehF;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -0,0 +1,304 @@
+"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 });
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const querystring = __importStar(require("querystring"));
+const rippleKeypairs = __importStar(require("ripple-keypairs"));
+const url = __importStar(require("url"));
+const xrpl = __importStar(require("xrpl"));
+const constants_1 = require("./constants");
+const keyPair_1 = require("./keyPair");
+const assert_1 = __importDefault(require("assert"));
+class Utils {
+    isValidAddress(address) {
+        try {
+            const addressDetails = this.getAddressDetails(address);
+            return address === this.normalizeAddress(addressDetails);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    isValidTransactionId(txId) {
+        return this.isValidHex(txId);
+    }
+    isValidPublicKey(key) {
+        try {
+            new keyPair_1.KeyPair({ pub: key });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isValidPrivateKey(key) {
+        try {
+            new keyPair_1.KeyPair({ prv: key });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    isValidSignature(signature) {
+        return this.isValidHex(signature);
+    }
+    isValidBlockId(hash) {
+        return this.isValidHex(hash);
+    }
+    isValidHex(hex) {
+        return /^([a-fA-F0-9])+$/.test(hex);
+    }
+    /**
+     * Parse an address string into address and destination tag
+     */
+    getAddressDetails(address) {
+        const destinationDetails = url.parse(address);
+        const destinationAddress = destinationDetails.pathname;
+        if (!destinationAddress || !xrpl.isValidClassicAddress(destinationAddress)) {
+            throw new sdk_core_1.InvalidAddressError(`destination address "${destinationAddress}" is not valid`);
+        }
+        // there are no other properties like destination tags
+        if (destinationDetails.pathname === address) {
+            return {
+                address: address,
+                destinationTag: undefined,
+            };
+        }
+        if (!destinationDetails.query) {
+            throw new sdk_core_1.InvalidAddressError('no query params present');
+        }
+        const queryDetails = querystring.parse(destinationDetails.query);
+        if (!queryDetails.dt) {
+            // if there are more properties, the query details need to contain the destination tag property.
+            throw new sdk_core_1.InvalidAddressError('destination tag missing');
+        }
+        if (Array.isArray(queryDetails.dt)) {
+            // if queryDetails.dt is an array, that means dt was given multiple times, which is not valid
+            throw new sdk_core_1.InvalidAddressError(`destination tag can appear at most once, but ${queryDetails.dt.length} destination tags were found`);
+        }
+        const parsedTag = parseInt(queryDetails.dt, 10);
+        if (!Number.isSafeInteger(parsedTag)) {
+            throw new sdk_core_1.InvalidAddressError('invalid destination tag');
+        }
+        if (parsedTag > 0xffffffff || parsedTag < 0) {
+            throw new sdk_core_1.InvalidAddressError('destination tag out of range');
+        }
+        return {
+            address: destinationAddress,
+            destinationTag: parsedTag,
+        };
+    }
+    /**
+     * Construct a full, normalized address from an address and destination tag
+     */
+    normalizeAddress({ address, destinationTag }) {
+        if (typeof address !== 'string') {
+            throw new sdk_core_1.InvalidAddressError('invalid address, expected string');
+        }
+        if (typeof destinationTag === 'undefined' || destinationTag === null) {
+            return address;
+        }
+        if (!Number.isInteger(destinationTag)) {
+            throw new sdk_core_1.InvalidAddressError('invalid destination tag, expected integer');
+        }
+        if (destinationTag > 0xffffffff || destinationTag < 0) {
+            throw new sdk_core_1.InvalidAddressError('destination tag out of range');
+        }
+        return `${address}?dt=${destinationTag}`;
+    }
+    /**
+     * @param message hex encoded string
+     * @param privateKey
+     * return hex encoded signature string, throws if any of the inputs are invalid
+     */
+    signString(message, privateKey) {
+        if (!this.isValidHex(message)) {
+            throw new sdk_core_1.UtilsError('message must be a hex encoded string');
+        }
+        if (!this.isValidPrivateKey(privateKey)) {
+            throw new sdk_core_1.UtilsError('invalid private key');
+        }
+        return rippleKeypairs.sign(message, privateKey);
+    }
+    /**
+     * @param message hex encoded string
+     * @param signature hex encooded signature string
+     * @param publicKey
+     * return boolean, throws if any of the inputs are invalid
+     */
+    verifySignature(message, signature, publicKey) {
+        if (!this.isValidHex(message)) {
+            throw new sdk_core_1.UtilsError('message must be a hex encoded string');
+        }
+        if (!this.isValidSignature(signature)) {
+            throw new sdk_core_1.UtilsError('invalid signature');
+        }
+        if (!this.isValidPublicKey(publicKey)) {
+            throw new sdk_core_1.UtilsError('invalid public key');
+        }
+        try {
+            return rippleKeypairs.verify(message, signature, publicKey);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {string} rawTransaction - Transaction in hex string format
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid raw transaction: Undefined');
+        }
+        if (!this.isValidHex(rawTransaction)) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid raw transaction: Hex string expected');
+        }
+        if (!this.isValidRawTransaction(rawTransaction)) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid raw transaction');
+        }
+    }
+    /**
+     * Checks if raw transaction can be deserialized
+     *
+     * @param {string} rawTransaction - transaction in base64 string format
+     * @returns {boolean} - the validation result
+     */
+    isValidRawTransaction(rawTransaction) {
+        try {
+            const jsonTx = xrpl.decode(rawTransaction);
+            xrpl.validate(jsonTx);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    validateAccountSetFlag(setFlag) {
+        if (typeof setFlag !== 'number') {
+            throw new sdk_core_1.UtilsError(`setFlag ${setFlag} is not valid`);
+        }
+        if (!constants_1.VALID_ACCOUNT_SET_FLAGS.includes(setFlag)) {
+            throw new sdk_core_1.UtilsError(`setFlag ${setFlag} is not a valid account set flag`);
+        }
+    }
+    validateSigner(signer) {
+        if (!signer.address) {
+            throw new sdk_core_1.UtilsError('signer must have an address');
+        }
+        if (!this.isValidAddress(signer.address)) {
+            throw new sdk_core_1.UtilsError(`signer address ${signer.address} is invalid`);
+        }
+        if (typeof signer.weight !== 'number' || signer.weight < 0) {
+            throw new sdk_core_1.UtilsError(`signer weight ${signer.weight} is not valid`);
+        }
+    }
+    /**
+     * Determines if the provided `amount` is for a token payment
+     */
+    isIssuedCurrencyAmount(amount) {
+        return (!!amount &&
+            typeof amount === 'object' &&
+            typeof amount.currency === 'string' &&
+            typeof amount.issuer === 'string' &&
+            typeof amount.value === 'string');
+    }
+    /**
+     * Get the associated XRP Currency details from token name. Throws an error if token is unsupported
+     * @param {string} tokenName - The token name
+     */
+    getXrpCurrencyFromTokenName(tokenName) {
+        if (!statics_1.coins.has(tokenName)) {
+            throw new sdk_core_1.UnsupportedTokenError(`${tokenName} is not supported`);
+        }
+        const token = statics_1.coins.get(tokenName);
+        if (!token.isToken || !(token instanceof statics_1.XrpCoin)) {
+            throw new sdk_core_1.UnsupportedTokenError(`${tokenName} is not an XRP token`);
+        }
+        return {
+            currency: token.currencyCode,
+            issuer: token.issuerAddress,
+        };
+    }
+    /**
+     * Decodes a serialized XRPL transaction.
+     *
+     * @param {string} txHex - The serialized transaction in hex.
+     * @returns {Object} - Decoded transaction object.
+     * @throws {Error} - If decoding fails or input is invalid.
+     */
+    decodeTransaction(txHex) {
+        if (typeof txHex !== 'string' || txHex.trim() === '') {
+            throw new Error('Invalid transaction hex. Expected a non-empty string.');
+        }
+        try {
+            return xrpl.decode(txHex);
+        }
+        catch (error) {
+            throw new Error(`Failed to decode transaction: ${error.message}`);
+        }
+    }
+    /**
+     * Get the statics coin object matching a given Xrp token issuer address and currency code if it exists
+     *
+     * @param issuerAddress The token issuer address to match against
+     * @param currencyCode The token currency code to match against
+     * @returns statics BaseCoin object for the matching token
+     */
+    getXrpToken(issuerAddress, currencyCode) {
+        const tokens = statics_1.coins.filter((coin) => {
+            if (coin instanceof statics_1.XrpCoin) {
+                return coin.issuerAddress === issuerAddress && coin.currencyCode === currencyCode;
+            }
+            return false;
+        });
+        const tokensArray = tokens.map((token) => token);
+        if (tokensArray.length >= 1) {
+            // there should never be two tokens with the same issuer address and currency code, so we assert that here
+            (0, assert_1.default)(tokensArray.length === 1);
+            return tokensArray[0];
+        }
+        return undefined;
+    }
+}
+const utils = new Utils();
+exports.default = utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseUtils,\n  InvalidAddressError,\n  InvalidTransactionError,\n  UnsupportedTokenError,\n  UtilsError,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin, coins, XrpCoin } from '@bitgo-beta/statics';\nimport * as querystring from 'querystring';\nimport * as rippleKeypairs from 'ripple-keypairs';\nimport * as url from 'url';\nimport * as xrpl from 'xrpl';\nimport { Amount, IssuedCurrencyAmount } from 'xrpl';\nimport { VALID_ACCOUNT_SET_FLAGS } from './constants';\nimport { Address, SignerDetails } from './iface';\nimport { KeyPair as XrpKeyPair } from './keyPair';\nimport assert from 'assert';\n\nclass Utils implements BaseUtils {\n  isValidAddress(address: string): boolean {\n    try {\n      const addressDetails = this.getAddressDetails(address);\n      return address === this.normalizeAddress(addressDetails);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidTransactionId(txId: string): boolean {\n    return this.isValidHex(txId);\n  }\n\n  isValidPublicKey(key: string): boolean {\n    try {\n      new XrpKeyPair({ pub: key });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  isValidPrivateKey(key: string): boolean {\n    try {\n      new XrpKeyPair({ prv: key });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  isValidSignature(signature: string): boolean {\n    return this.isValidHex(signature);\n  }\n\n  isValidBlockId(hash: string): boolean {\n    return this.isValidHex(hash);\n  }\n\n  isValidHex(hex: string): boolean {\n    return /^([a-fA-F0-9])+$/.test(hex);\n  }\n\n  /**\n   * Parse an address string into address and destination tag\n   */\n  public getAddressDetails(address: string): Address {\n    const destinationDetails = url.parse(address);\n    const destinationAddress = destinationDetails.pathname;\n    if (!destinationAddress || !xrpl.isValidClassicAddress(destinationAddress)) {\n      throw new InvalidAddressError(`destination address \"${destinationAddress}\" is not valid`);\n    }\n    // there are no other properties like destination tags\n    if (destinationDetails.pathname === address) {\n      return {\n        address: address,\n        destinationTag: undefined,\n      };\n    }\n\n    if (!destinationDetails.query) {\n      throw new InvalidAddressError('no query params present');\n    }\n\n    const queryDetails = querystring.parse(destinationDetails.query);\n    if (!queryDetails.dt) {\n      // if there are more properties, the query details need to contain the destination tag property.\n      throw new InvalidAddressError('destination tag missing');\n    }\n\n    if (Array.isArray(queryDetails.dt)) {\n      // if queryDetails.dt is an array, that means dt was given multiple times, which is not valid\n      throw new InvalidAddressError(\n        `destination tag can appear at most once, but ${queryDetails.dt.length} destination tags were found`\n      );\n    }\n\n    const parsedTag = parseInt(queryDetails.dt, 10);\n    if (!Number.isSafeInteger(parsedTag)) {\n      throw new InvalidAddressError('invalid destination tag');\n    }\n\n    if (parsedTag > 0xffffffff || parsedTag < 0) {\n      throw new InvalidAddressError('destination tag out of range');\n    }\n\n    return {\n      address: destinationAddress,\n      destinationTag: parsedTag,\n    };\n  }\n\n  /**\n   * Construct a full, normalized address from an address and destination tag\n   */\n  public normalizeAddress({ address, destinationTag }: Address): string {\n    if (typeof address !== 'string') {\n      throw new InvalidAddressError('invalid address, expected string');\n    }\n    if (typeof destinationTag === 'undefined' || destinationTag === null) {\n      return address;\n    }\n    if (!Number.isInteger(destinationTag)) {\n      throw new InvalidAddressError('invalid destination tag, expected integer');\n    }\n    if (destinationTag > 0xffffffff || destinationTag < 0) {\n      throw new InvalidAddressError('destination tag out of range');\n    }\n    return `${address}?dt=${destinationTag}`;\n  }\n\n  /**\n   * @param message hex encoded string\n   * @param privateKey\n   * return hex encoded signature string, throws if any of the inputs are invalid\n   */\n  public signString(message: string, privateKey: string): string {\n    if (!this.isValidHex(message)) {\n      throw new UtilsError('message must be a hex encoded string');\n    }\n    if (!this.isValidPrivateKey(privateKey)) {\n      throw new UtilsError('invalid private key');\n    }\n    return rippleKeypairs.sign(message, privateKey);\n  }\n\n  /**\n   * @param message hex encoded string\n   * @param signature hex encooded signature string\n   * @param publicKey\n   * return boolean, throws if any of the inputs are invalid\n   */\n  public verifySignature(message: string, signature: string, publicKey: string): boolean {\n    if (!this.isValidHex(message)) {\n      throw new UtilsError('message must be a hex encoded string');\n    }\n    if (!this.isValidSignature(signature)) {\n      throw new UtilsError('invalid signature');\n    }\n    if (!this.isValidPublicKey(publicKey)) {\n      throw new UtilsError('invalid public key');\n    }\n    try {\n      return rippleKeypairs.verify(message, signature, publicKey);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param {string} rawTransaction - Transaction in hex string format\n   */\n  public validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Invalid raw transaction: Undefined');\n    }\n    if (!this.isValidHex(rawTransaction)) {\n      throw new InvalidTransactionError('Invalid raw transaction: Hex string expected');\n    }\n    if (!this.isValidRawTransaction(rawTransaction)) {\n      throw new InvalidTransactionError('Invalid raw transaction');\n    }\n  }\n\n  /**\n   * Checks if raw transaction can be deserialized\n   *\n   * @param {string} rawTransaction - transaction in base64 string format\n   * @returns {boolean} - the validation result\n   */\n  public isValidRawTransaction(rawTransaction: string): boolean {\n    try {\n      const jsonTx = xrpl.decode(rawTransaction);\n      xrpl.validate(jsonTx);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  public validateAccountSetFlag(setFlag: number) {\n    if (typeof setFlag !== 'number') {\n      throw new UtilsError(`setFlag ${setFlag} is not valid`);\n    }\n    if (!VALID_ACCOUNT_SET_FLAGS.includes(setFlag)) {\n      throw new UtilsError(`setFlag ${setFlag} is not a valid account set flag`);\n    }\n  }\n\n  public validateSigner(signer: SignerDetails): void {\n    if (!signer.address) {\n      throw new UtilsError('signer must have an address');\n    }\n    if (!this.isValidAddress(signer.address)) {\n      throw new UtilsError(`signer address ${signer.address} is invalid`);\n    }\n    if (typeof signer.weight !== 'number' || signer.weight < 0) {\n      throw new UtilsError(`signer weight ${signer.weight} is not valid`);\n    }\n  }\n\n  /**\n   * Determines if the provided `amount` is for a token payment\n   */\n  public isIssuedCurrencyAmount(amount: Amount): amount is IssuedCurrencyAmount {\n    return (\n      !!amount &&\n      typeof amount === 'object' &&\n      typeof amount.currency === 'string' &&\n      typeof amount.issuer === 'string' &&\n      typeof amount.value === 'string'\n    );\n  }\n\n  /**\n   * Get the associated XRP Currency details from token name. Throws an error if token is unsupported\n   * @param {string} tokenName - The token name\n   */\n  public getXrpCurrencyFromTokenName(tokenName: string): xrpl.IssuedCurrency {\n    if (!coins.has(tokenName)) {\n      throw new UnsupportedTokenError(`${tokenName} is not supported`);\n    }\n    const token = coins.get(tokenName);\n    if (!token.isToken || !(token instanceof XrpCoin)) {\n      throw new UnsupportedTokenError(`${tokenName} is not an XRP token`);\n    }\n    return {\n      currency: token.currencyCode,\n      issuer: token.issuerAddress,\n    };\n  }\n\n  /**\n   * Decodes a serialized XRPL transaction.\n   *\n   * @param {string} txHex - The serialized transaction in hex.\n   * @returns {Object} - Decoded transaction object.\n   * @throws {Error} - If decoding fails or input is invalid.\n   */\n  public decodeTransaction(txHex: string) {\n    if (typeof txHex !== 'string' || txHex.trim() === '') {\n      throw new Error('Invalid transaction hex. Expected a non-empty string.');\n    }\n    try {\n      return xrpl.decode(txHex);\n    } catch (error) {\n      throw new Error(`Failed to decode transaction: ${error.message}`);\n    }\n  }\n\n  /**\n   * Get the statics coin object matching a given Xrp token issuer address and currency code if it exists\n   *\n   * @param issuerAddress The token issuer address to match against\n   * @param currencyCode The token currency code to match against\n   * @returns statics BaseCoin object for the matching token\n   */\n  public getXrpToken(issuerAddress, currencyCode): Readonly<BaseCoin> | undefined {\n    const tokens = coins.filter((coin) => {\n      if (coin instanceof XrpCoin) {\n        return coin.issuerAddress === issuerAddress && coin.currencyCode === currencyCode;\n      }\n      return false;\n    });\n    const tokensArray = tokens.map((token) => token);\n    if (tokensArray.length >= 1) {\n      // there should never be two tokens with the same issuer address and currency code, so we assert that here\n      assert(tokensArray.length === 1);\n      return tokensArray[0];\n    }\n    return undefined;\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/dist/src/lib/walletInitializationBuilder.d.ts

@@ -0,0 +1,19 @@
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { SignerEntry } from 'xrpl/dist/npm/models/common';
+import { SignerDetails } from './iface';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class WalletInitializationBuilder extends TransactionBuilder {
+    protected _signerQuorum: number;
+    protected _signerEntries: SignerEntry[];
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    protected get xrpTransactionType(): 'SignerListSet';
+    signerQuorum(quorum: number): TransactionBuilder;
+    signer(signer: SignerDetails): TransactionBuilder;
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=walletInitializationBuilder.d.ts.map

package/dist/src/lib/walletInitializationBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletInitializationBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/walletInitializationBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,2BAA4B,SAAQ,kBAAkB;IACjE,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,cAAc,EAAE,WAAW,EAAE,CAAM;gBACjC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,SAAS,KAAK,kBAAkB,IAAI,eAAe,CAElD;IAED,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB;IAQhD,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,kBAAkB;IAWjD,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAkBlC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAuB5D"}