@bitgo-beta/sdk-coin-xrp 1.3.3-alpha.23 → 1.3.3-alpha.231

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,61 @@
+import { BaseUtils } from '@bitgo-beta/sdk-core';
+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;
+}
+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;AAK9B,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;AAGjD,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;CAa3E;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -0,0 +1,250 @@
+"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;
+};
+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");
+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,
+        };
+    }
+}
+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 { 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';\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\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"}

package/dist/src/lib/walletInitializationBuilder.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletInitializationBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("./constants");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class WalletInitializationBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signerEntries = [];
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.WalletInitialization;
+    }
+    get xrpTransactionType() {
+        return 'SignerListSet';
+    }
+    signerQuorum(quorum) {
+        if (typeof quorum !== 'number' || quorum < 1) {
+            throw new Error(`quorum must be a valid number greater than 0, got: ${quorum}`);
+        }
+        this._signerQuorum = quorum;
+        return this;
+    }
+    signer(signer) {
+        if (this._signerEntries.length > constants_1.MAX_SIGNERS) {
+            throw new sdk_core_1.BuildTransactionError(`Cannot have more than ${constants_1.MAX_SIGNERS} signers`);
+        }
+        utils_1.default.validateSigner(signer);
+        this._signerEntries.push({
+            SignerEntry: { Account: signer.address, SignerWeight: signer.weight },
+        });
+        return this;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const { signerEntries, signerQuorum } = tx.toJson();
+        if (signerQuorum) {
+            this.signerQuorum(signerQuorum);
+        }
+        if (signerEntries === null || signerEntries === void 0 ? void 0 : signerEntries.length) {
+            signerEntries.forEach((signer) => this.signer({
+                address: signer.SignerEntry.Account,
+                weight: signer.SignerEntry.SignerWeight,
+            }));
+        }
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        if (!this._sender) {
+            throw new sdk_core_1.BuildTransactionError('Sender must be set before building the transaction');
+        }
+        if (!this._signerQuorum || this._signerQuorum < constants_1.MIN_SIGNER_QUORUM) {
+            throw new sdk_core_1.BuildTransactionError('Signer quorum must be set before building the transaction');
+        }
+        if (!this._signerEntries) {
+            throw new sdk_core_1.BuildTransactionError('Signers must be set before building the transaction');
+        }
+        if (this._signerEntries.length < constants_1.MIN_SIGNERS || this._signerEntries.length > constants_1.MAX_SIGNERS) {
+            throw new sdk_core_1.BuildTransactionError(`Signers must be between ${constants_1.MIN_SIGNERS} and ${constants_1.MAX_SIGNERS}`);
+        }
+        this._specificFields = {
+            TransactionType: this.xrpTransactionType,
+            Account: this._sender,
+            SignerQuorum: this._signerQuorum,
+            SignerEntries: this._signerEntries,
+        };
+        return await super.buildImplementation();
+    }
+}
+exports.WalletInitializationBuilder = WalletInitializationBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAGzC,CAAC"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAKjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAMzC,CAAC"}

package/dist/src/register.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.register = void 0;
 const txrp_1 = require("./txrp");
 const xrp_1 = require("./xrp");
+const xrpToken_1 = require("./xrpToken");
 const register = (sdk) => {
     sdk.register('xrp', xrp_1.Xrp.createInstance);
     sdk.register('txrp', txrp_1.Txrp.createInstance);
+    xrpToken_1.XrpToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+        sdk.register(name, coinConstructor);
+    });
 };
 exports.register = register;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsaUNBQThCO0FBQzlCLCtCQUE0QjtBQUVyQixNQUFNLFFBQVEsR0FBRyxDQUFDLEdBQWMsRUFBUSxFQUFFO0lBQy9DLEdBQUcsQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLFNBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUN4QyxHQUFHLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxXQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7QUFDNUMsQ0FBQyxDQUFDO0FBSFcsUUFBQSxRQUFRLFlBR25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHhycCB9IGZyb20gJy4vdHhycCc7XG5pbXBvcnQgeyBYcnAgfSBmcm9tICcuL3hycCc7XG5cbmV4cG9ydCBjb25zdCByZWdpc3RlciA9IChzZGs6IEJpdEdvQmFzZSk6IHZvaWQgPT4ge1xuICBzZGsucmVnaXN0ZXIoJ3hycCcsIFhycC5jcmVhdGVJbnN0YW5jZSk7XG4gIHNkay5yZWdpc3RlcigndHhycCcsIFR4cnAuY3JlYXRlSW5zdGFuY2UpO1xufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsaUNBQThCO0FBQzlCLCtCQUE0QjtBQUM1Qix5Q0FBc0M7QUFFL0IsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFjLEVBQVEsRUFBRTtJQUMvQyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxTQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDeEMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzFDLG1CQUFRLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQ3ZFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBTlcsUUFBQSxRQUFRLFlBTW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHhycCB9IGZyb20gJy4vdHhycCc7XG5pbXBvcnQgeyBYcnAgfSBmcm9tICcuL3hycCc7XG5pbXBvcnQgeyBYcnBUb2tlbiB9IGZyb20gJy4veHJwVG9rZW4nO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCd4cnAnLCBYcnAuY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3R4cnAnLCBUeHJwLmNyZWF0ZUluc3RhbmNlKTtcbiAgWHJwVG9rZW4uY3JlYXRlVG9rZW5Db25zdHJ1Y3RvcnMoKS5mb3JFYWNoKCh7IG5hbWUsIGNvaW5Db25zdHJ1Y3RvciB9KSA9PiB7XG4gICAgc2RrLnJlZ2lzdGVyKG5hbWUsIGNvaW5Db25zdHJ1Y3Rvcik7XG4gIH0pO1xufTtcbiJdfQ==