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

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?.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==

package/dist/src/ripple.d.ts

@@ -1,7 +1,117 @@
 /**
  * @hidden
  */
-import * as ripple from 'ripple-lib';
-declare const _default: (params: any) => ripple.RippleAPI;
+/**
+ */
+import * as rippleKeypairs from 'ripple-keypairs';
+import * as xrpl from 'xrpl';
+declare const _default: {
+    signWithPrivateKey: (txHex: any, privateKey: any, options: any) => {
+        signedTransaction: string;
+        id: string;
+    };
+    Client: typeof xrpl.Client;
+    ECDSA: typeof xrpl.ECDSA;
+    Wallet: typeof xrpl.Wallet;
+    walletFromSecretNumbers: typeof xrpl.walletFromSecretNumbers;
+    keyToRFC1751Mnemonic: typeof xrpl.keyToRFC1751Mnemonic;
+    rfc1751MnemonicToKey: typeof xrpl.rfc1751MnemonicToKey;
+    LedgerEntry: typeof xrpl.LedgerEntry;
+    setTransactionFlagsToNumber: typeof xrpl.setTransactionFlagsToNumber;
+    parseAccountRootFlags: typeof xrpl.parseAccountRootFlags;
+    validate: typeof xrpl.validate;
+    AccountSetAsfFlags: typeof xrpl.AccountSetAsfFlags;
+    AccountSetTfFlags: typeof xrpl.AccountSetTfFlags;
+    AMMDepositFlags: typeof xrpl.AMMDepositFlags;
+    AMMWithdrawFlags: typeof xrpl.AMMWithdrawFlags;
+    EnableAmendmentFlags: typeof xrpl.EnableAmendmentFlags;
+    NFTokenCreateOfferFlags: typeof xrpl.NFTokenCreateOfferFlags;
+    NFTokenMintFlags: typeof xrpl.NFTokenMintFlags;
+    OfferCreateFlags: typeof xrpl.OfferCreateFlags;
+    PaymentFlags: typeof xrpl.PaymentFlags;
+    PaymentChannelClaimFlags: typeof xrpl.PaymentChannelClaimFlags;
+    TrustSetFlags: typeof xrpl.TrustSetFlags;
+    XChainModifyBridgeFlags: typeof xrpl.XChainModifyBridgeFlags;
+    isCreatedNode(node: xrpl.Node): node is xrpl.CreatedNode;
+    isModifiedNode(node: xrpl.Node): node is xrpl.ModifiedNode;
+    isDeletedNode(node: xrpl.Node): node is xrpl.DeletedNode;
+    RIPPLED_API_V1: 1;
+    RIPPLED_API_V2: 2;
+    DEFAULT_API_VERSION: 2;
+    getBalanceChanges: typeof xrpl.getBalanceChanges;
+    dropsToXrp: typeof xrpl.dropsToXrp;
+    xrpToDrops: typeof xrpl.xrpToDrops;
+    hasNextPage: typeof xrpl.hasNextPage;
+    rippleTimeToISOTime: typeof xrpl.rippleTimeToISOTime;
+    isoTimeToRippleTime: typeof xrpl.isoTimeToRippleTime;
+    rippleTimeToUnixTime: typeof xrpl.rippleTimeToUnixTime;
+    unixTimeToRippleTime: typeof xrpl.unixTimeToRippleTime;
+    percentToQuality: typeof xrpl.percentToQuality;
+    decimalToQuality: typeof xrpl.decimalToQuality;
+    percentToTransferRate: typeof xrpl.percentToTransferRate;
+    decimalToTransferRate: typeof xrpl.decimalToTransferRate;
+    transferRateToDecimal: typeof xrpl.transferRateToDecimal;
+    qualityToDecimal: typeof xrpl.qualityToDecimal;
+    isValidSecret: typeof xrpl.isValidSecret;
+    isValidAddress: typeof xrpl.isValidAddress;
+    hashes: {
+        hashSignedTx: typeof import("xrpl/dist/npm/utils/hashes").hashSignedTx;
+        hashTx: typeof import("xrpl/dist/npm/utils/hashes").hashTx;
+        hashAccountRoot: typeof import("xrpl/dist/npm/utils/hashes").hashAccountRoot;
+        hashSignerListId: typeof import("xrpl/dist/npm/utils/hashes").hashSignerListId;
+        hashOfferId: typeof import("xrpl/dist/npm/utils/hashes").hashOfferId;
+        hashTrustline: typeof import("xrpl/dist/npm/utils/hashes").hashTrustline;
+        hashTxTree: typeof import("xrpl/dist/npm/utils/hashes").hashTxTree;
+        hashStateTree: typeof import("xrpl/dist/npm/utils/hashes").hashStateTree;
+        hashLedger: typeof import("xrpl/dist/npm/utils/hashes").hashLedger;
+        hashLedgerHeader: typeof import("xrpl/dist/npm/utils/hashes").hashLedgerHeader;
+        hashEscrow: typeof import("xrpl/dist/npm/utils/hashes").hashEscrow;
+        hashPaymentChannel: typeof import("xrpl/dist/npm/utils/hashes").hashPaymentChannel;
+    };
+    deriveKeypair: typeof rippleKeypairs.deriveKeypair;
+    deriveAddress: typeof rippleKeypairs.deriveAddress;
+    deriveXAddress: typeof xrpl.deriveXAddress;
+    signPaymentChannelClaim: typeof xrpl.signPaymentChannelClaim;
+    verifyKeypairSignature: typeof rippleKeypairs.verify;
+    verifyPaymentChannelClaim: typeof xrpl.verifyPaymentChannelClaim;
+    convertStringToHex: typeof xrpl.convertStringToHex;
+    convertHexToString: typeof xrpl.convertHexToString;
+    classicAddressToXAddress: typeof xrpl.classicAddressToXAddress;
+    xAddressToClassicAddress: typeof xrpl.xAddressToClassicAddress;
+    isValidXAddress: typeof xrpl.isValidXAddress;
+    isValidClassicAddress: typeof xrpl.isValidClassicAddress;
+    encodeSeed: typeof xrpl.encodeSeed;
+    decodeSeed: typeof rippleKeypairs.decodeSeed;
+    encodeAccountID: typeof xrpl.encodeAccountID;
+    decodeAccountID: typeof xrpl.decodeAccountID;
+    encodeNodePublic: typeof xrpl.encodeNodePublic;
+    decodeNodePublic: typeof xrpl.decodeNodePublic;
+    encodeAccountPublic: typeof xrpl.encodeAccountPublic;
+    decodeAccountPublic: typeof xrpl.decodeAccountPublic;
+    encodeXAddress: typeof xrpl.encodeXAddress;
+    decodeXAddress: typeof xrpl.decodeXAddress;
+    encode: typeof xrpl.encode;
+    decode: typeof xrpl.decode;
+    encodeForMultiSigning: typeof xrpl.encodeForMultiSigning;
+    encodeForSigning: typeof xrpl.encodeForSigning;
+    encodeForSigningClaim: typeof xrpl.encodeForSigningClaim;
+    getNFTokenID: typeof xrpl.getNFTokenID;
+    parseNFTokenID: typeof xrpl.parseNFTokenID;
+    getXChainClaimID: typeof xrpl.getXChainClaimID;
+    XrplError: typeof xrpl.XrplError;
+    UnexpectedError: typeof xrpl.UnexpectedError;
+    ConnectionError: typeof xrpl.ConnectionError;
+    RippledError: typeof xrpl.RippledError;
+    NotConnectedError: typeof xrpl.NotConnectedError;
+    DisconnectedError: typeof xrpl.DisconnectedError;
+    RippledNotInitializedError: typeof xrpl.RippledNotInitializedError;
+    TimeoutError: typeof xrpl.TimeoutError;
+    ResponseFormatError: typeof xrpl.ResponseFormatError;
+    ValidationError: typeof xrpl.ValidationError;
+    NotFoundError: typeof xrpl.NotFoundError;
+    XRPLFaucetError: typeof xrpl.XRPLFaucetError;
+    verifySignature: typeof xrpl.verifySignature;
+    multisign: typeof xrpl.multisign;
+};
 export = _default;
 //# sourceMappingURL=ripple.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ripple.d.ts","sourceRoot":"","sources":["../../src/ripple.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,MAAM,MAAM,YAAY,CAAC;yCA+DlB,OAAO,SAAS;AAAnC,kBAIE"}
+{"version":3,"file":"ripple.d.ts","sourceRoot":"","sources":["../../src/ripple.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;GACG;AACH,OAAO,KAAK,cAAc,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsF7B,kBAAyC"}

package/dist/src/ripple.js

@@ -4,7 +4,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -14,20 +18,44 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __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 };
 };
 /**
  */
 const rippleKeypairs = __importStar(require("ripple-keypairs"));
-const ripple = __importStar(require("ripple-lib"));
-const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const xrpl = __importStar(require("xrpl"));
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const binary = __importStar(require("ripple-binary-codec"));
-const hashes_1 = require("ripple-lib/dist/npm/common/hashes");
+/**
+ * Convert an XRP address to a BigNumber for numeric comparison.
+ * This is needed for proper sorting of signers as required by the XRP protocol.
+ *
+ * @param address - The XRP address to convert
+ * @returns BigNumber representation of the address
+ */
+function addressToBigNumber(address) {
+    const hex = Buffer.from(xrpl.decodeAccountID(address)).toString('hex');
+    return new bignumber_js_1.default(hex, 16);
+}
 function computeSignature(tx, privateKey, signAs) {
     const signingData = signAs ? binary.encodeForMultisigning(tx, signAs) : binary.encodeForSigning(tx);
     return rippleKeypairs.sign(signingData, privateKey);
@@ -44,7 +72,7 @@ const signWithPrivateKey = function (txHex, privateKey, options) {
     if (privateKeyBuffer.length === 33 && privateKeyBuffer[0] === 0) {
         privateKeyBuffer = privateKeyBuffer.slice(1, 33);
     }
-    const publicKey = utxo_lib_1.ECPair.fromPrivateKey(privateKeyBuffer).publicKey.toString('hex').toUpperCase();
+    const publicKey = secp256k1_1.ECPair.fromPrivateKey(privateKeyBuffer).publicKey.toString('hex').toUpperCase();
     let tx;
     try {
         tx = binary.decode(txHex);
@@ -57,9 +85,6 @@ const signWithPrivateKey = function (txHex, privateKey, options) {
             throw new Error('txHex needs to be either hex or JSON string for XRP');
         }
     }
-    if (tx.TxnSignature || tx.Signers) {
-        throw new Error('transaction must not contain "TxnSignature" or "Signers" properties');
-    }
     tx.SigningPubKey = options && options.signAs ? '' : publicKey;
     if (options && options.signAs) {
         const expectedSigner = rippleKeypairs.deriveAddress(publicKey);
@@ -71,7 +96,21 @@ const signWithPrivateKey = function (txHex, privateKey, options) {
             SigningPubKey: publicKey,
             TxnSignature: computeSignature(tx, privateKey, options.signAs),
         };
-        tx.Signers = [{ Signer: signer }];
+        // Ordering of private key signing matters, or the Ripple fullnode will throw an 'Unsorted Signers array' error.
+        // XRP requires Signers array to be sorted based on numeric value of signer addresses (lowest first)
+        if (tx.Signers) {
+            // Add the current signer
+            tx.Signers.push({ Signer: signer });
+            // Sort the Signers array by numeric value of Account (address) to ensure proper ordering
+            tx.Signers.sort((a, b) => {
+                const addressBN1 = addressToBigNumber(a.Signer.Account);
+                const addressBN2 = addressToBigNumber(b.Signer.Account);
+                return addressBN1.comparedTo(addressBN2);
+            });
+        }
+        else {
+            tx.Signers = [{ Signer: signer }];
+        }
     }
     else {
         tx.TxnSignature = computeSignature(tx, privateKey, undefined);
@@ -79,12 +118,8 @@ const signWithPrivateKey = function (txHex, privateKey, options) {
     const serialized = binary.encode(tx);
     return {
         signedTransaction: serialized,
-        id: hashes_1.computeBinaryTransactionHash(serialized),
+        id: xrpl.hashes.hashSignedTx(serialized),
     };
 };
-module.exports = (params) => {
-    const rippleLib = new ripple.RippleAPI(params);
-    rippleLib.signWithPrivateKey = signWithPrivateKey;
-    return rippleLib;
-};
-//# sourceMappingURL=data:application/json;base64,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
+module.exports = { ...xrpl, signWithPrivateKey };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/txrp.d.ts

@@ -4,10 +4,11 @@
  * @format
  */
 import { BaseCoin, BitGoBase } from '@bitgo-beta/sdk-core';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
 import { Xrp } from './xrp';
 export declare class Txrp extends Xrp {
-    protected constructor(bitgo: BitGoBase);
-    static createInstance(bitgo: BitGoBase): BaseCoin;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
     /**
      * Identifier for the blockchain which supports this coin
      */

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

@@ -1 +1 @@
-{"version":3,"file":"txrp.d.ts","sourceRoot":"","sources":["../../src/txrp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5B,qBAAa,IAAK,SAAQ,GAAG;IAC3B,SAAS,aAAa,KAAK,EAAE,SAAS;IAItC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ;IAGjD;;OAEG;IACI,QAAQ,IAAI,MAAM;IAIzB;;OAEG;IACI,aAAa,IAAI,MAAM;IAI9B;;OAEG;IACI,WAAW,IAAI,MAAM;CAG7B"}
+{"version":3,"file":"txrp.d.ts","sourceRoot":"","sources":["../../src/txrp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5B,qBAAa,IAAK,SAAQ,GAAG;IAC3B,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAG1F;;OAEG;IACI,QAAQ,IAAI,MAAM;IAIzB;;OAEG;IACI,aAAa,IAAI,MAAM;IAI9B;;OAEG;IACI,WAAW,IAAI,MAAM;CAG7B"}

package/dist/src/txrp.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Txrp = void 0;
 const xrp_1 = require("./xrp");
 class Txrp extends xrp_1.Xrp {
-    constructor(bitgo) {
-        super(bitgo);
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
     }
-    static createInstance(bitgo) {
-        return new Txrp(bitgo);
+    static createInstance(bitgo, staticsCoin) {
+        return new Txrp(bitgo, staticsCoin);
     }
     /**
      * Identifier for the blockchain which supports this coin
@@ -29,4 +29,4 @@ class Txrp extends xrp_1.Xrp {
     }
 }
 exports.Txrp = Txrp;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhycC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eHJwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQU1BLCtCQUE0QjtBQUU1QixNQUFhLElBQUssU0FBUSxTQUFHO0lBQzNCLFlBQXNCLEtBQWdCO1FBQ3BDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNmLENBQUM7SUFFRCxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQWdCO1FBQ3BDLE9BQU8sSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDekIsQ0FBQztJQUNEOztPQUVHO0lBQ0ksUUFBUTtRQUNiLE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRDs7T0FFRztJQUNJLGFBQWE7UUFDbEIsT0FBTyx1Q0FBdUMsQ0FBQztJQUNqRCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxXQUFXO1FBQ2hCLE9BQU8sZ0JBQWdCLENBQUM7SUFDMUIsQ0FBQztDQUNGO0FBNUJELG9CQTRCQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGVzdG5ldCBYUlBcbiAqXG4gKiBAZm9ybWF0XG4gKi9cbmltcG9ydCB7IEJhc2VDb2luLCBCaXRHb0Jhc2UgfSBmcm9tICdAYml0Z28tYmV0YS9zZGstY29yZSc7XG5pbXBvcnQgeyBYcnAgfSBmcm9tICcuL3hycCc7XG5cbmV4cG9ydCBjbGFzcyBUeHJwIGV4dGVuZHMgWHJwIHtcbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKGJpdGdvOiBCaXRHb0Jhc2UpIHtcbiAgICBzdXBlcihiaXRnbyk7XG4gIH1cblxuICBzdGF0aWMgY3JlYXRlSW5zdGFuY2UoYml0Z286IEJpdEdvQmFzZSk6IEJhc2VDb2luIHtcbiAgICByZXR1cm4gbmV3IFR4cnAoYml0Z28pO1xuICB9XG4gIC8qKlxuICAgKiBJZGVudGlmaWVyIGZvciB0aGUgYmxvY2tjaGFpbiB3aGljaCBzdXBwb3J0cyB0aGlzIGNvaW5cbiAgICovXG4gIHB1YmxpYyBnZXRDaGFpbigpOiBzdHJpbmcge1xuICAgIHJldHVybiAndHhycCc7XG4gIH1cblxuICAvKipcbiAgICogVVJMIG9mIGEgd2VsbC1rbm93biwgcHVibGljIGZhY2luZyAobm9uLWJpdGdvKSByaXBwbGVkIGluc3RhbmNlIHdoaWNoIGNhbiBiZSB1c2VkIGZvciByZWNvdmVyeVxuICAgKi9cbiAgcHVibGljIGdldFJpcHBsZWRVcmwoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gJ2h0dHBzOi8vcy5hbHRuZXQucmlwcGxldGVzdC5uZXQ6NTEyMzQnO1xuICB9XG5cbiAgLyoqXG4gICAqIENvbXBsZXRlIGh1bWFuLXJlYWRhYmxlIG5hbWUgb2YgdGhpcyBjb2luXG4gICAqL1xuICBwdWJsaWMgZ2V0RnVsbE5hbWUoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gJ1Rlc3RuZXQgUmlwcGxlJztcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/xrp.d.ts

@@ -1,56 +1,10 @@
-/// <reference types="node" />
-import { BaseCoin, BitGoBase, InitiateRecoveryOptions as BaseInitiateRecoveryOptions, KeyPair, ParsedTransaction, ParseTransactionOptions, SignTransactionOptions as BaseSignTransactionOptions, TransactionExplanation, TransactionPrebuild, VerifyAddressOptions as BaseVerifyAddressOptions, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
-interface Address {
-    address: string;
-    destinationTag?: number;
-}
-interface FeeInfo {
-    date: string;
-    height: number;
-    baseReserve: string;
-    baseFee: string;
-}
-interface SignTransactionOptions extends BaseSignTransactionOptions {
-    txPrebuild: TransactionPrebuild;
-    prv: string;
-}
-interface ExplainTransactionOptions {
-    txHex?: string;
-}
-interface VerifyAddressOptions extends BaseVerifyAddressOptions {
-    rootAddress: string;
-}
-interface RecoveryInfo extends TransactionExplanation {
-    txHex: string;
-    backupKey?: string;
-    coin?: string;
-}
-export interface RecoveryTransaction {
-    txHex: string;
-}
-export interface InitiateRecoveryOptions extends BaseInitiateRecoveryOptions {
-    krsProvider?: string;
-}
-export interface RecoveryOptions {
-    backupKey: string;
-    userKey: string;
-    rootAddress: string;
-    recoveryDestination: string;
-    bitgoKey?: string;
-    walletPassphrase: string;
-    krsProvider?: string;
-}
-interface HalfSignedTransaction {
-    halfSigned: {
-        txHex: string;
-    };
-}
-interface SupplementGenerateWalletOptions {
-    rootPrivateKey?: string;
-}
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, KeyPair, MultisigType, ParsedTransaction, ParseTransactionOptions, TokenEnablementConfig, TransactionParams, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
+import { BaseCoin as StaticsBaseCoin, XrpCoin } from '@bitgo-beta/statics';
+import { ExplainTransactionOptions, FeeInfo, HalfSignedTransaction, RecoveryInfo, RecoveryOptions, RecoveryTransaction, SignTransactionOptions, SupplementGenerateWalletOptions, TransactionExplanation, VerifyAddressOptions, XrpTransactionType } from './lib/iface';
 export declare class Xrp extends BaseCoin {
-    protected constructor(bitgo: BitGoBase);
-    static createInstance(bitgo: BitGoBase): BaseCoin;
+    protected _staticsCoin: Readonly<StaticsBaseCoin>;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
     /**
      * Factor between the coin's base unit and its smallest subdivison
      */
@@ -67,14 +21,6 @@ export declare class Xrp extends BaseCoin {
      * Complete human-readable name of this coin
      */
     getFullName(): string;
-    /**
-     * 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;
     /**
      * Evaluates whether an address string is valid for this coin
      * @param address
@@ -91,6 +37,11 @@ export declare class Xrp extends BaseCoin {
      * Get fee info from server
      */
     getFeeInfo(): Promise<FeeInfo>;
+    /** @inheritdoc */
+    valuelessTransferAllowed(): boolean;
+    /** inherited doc */
+    getDefaultMultisigType(): MultisigType;
+    getTokenEnablementConfig(): TokenEnablementConfig;
     /**
      * Assemble keychain and half-sign prebuilt transaction
      * @param params
@@ -98,7 +49,7 @@ export declare class Xrp extends BaseCoin {
      * - prv
      * @returns Bluebird<HalfSignedTransaction>
      */
-    signTransaction({ txPrebuild, prv }: SignTransactionOptions): Promise<HalfSignedTransaction>;
+    signTransaction({ txPrebuild, prv, isLastSignature, }: SignTransactionOptions): Promise<HalfSignedTransaction | RecoveryTransaction>;
     /**
      * Ripple requires additional parameters for wallet generation to be sent to the server. The additional parameters are
      * the root public key, which is the basis of the root address, two signed, and one half-signed initialization txs
@@ -111,6 +62,12 @@ export declare class Xrp extends BaseCoin {
      * @param params
      */
     explainTransaction(params?: ExplainTransactionOptions): Promise<TransactionExplanation>;
+    getTransactionTypeRawTxHex(txHex: string): XrpTransactionType | undefined;
+    verifyTxType(txPrebuildDecoded: TransactionExplanation, txHexPrebuild: string | undefined): void;
+    verifyTokenName(txParams: TransactionParams, txPrebuildDecoded: TransactionExplanation, txHexPrebuild: string | undefined, coinConfig: XrpCoin): void;
+    verifyActivationAddress(txParams: TransactionParams, txPrebuildDecoded: TransactionExplanation): void;
+    verifyTokenIssuer(txParams: TransactionParams, txPrebuildDecoded: TransactionExplanation): void;
+    verifyRequiredKeys(txParams: TransactionParams, txPrebuildDecoded: TransactionExplanation): void;
     /**
      * Verify that a transaction prebuild complies with the original intention
      * @param txParams params object passed to send
@@ -118,7 +75,7 @@ export declare class Xrp extends BaseCoin {
      * @param wallet
      * @returns {boolean}
      */
-    verifyTransaction({ txParams, txPrebuild }: VerifyTransactionOptions): Promise<boolean>;
+    verifyTransaction({ txParams, txPrebuild, verification }: VerifyTransactionOptions): Promise<boolean>;
     /**
      * Check if address is a valid XRP address, and then make sure the root addresses match.
      * This prevents attacks where an attack may switch out the new address for one of their own
@@ -143,13 +100,17 @@ export declare class Xrp extends BaseCoin {
      * - recoveryDestination: target address to send recovered funds to
      */
     recover(params: RecoveryOptions): Promise<RecoveryInfo | RecoveryTransaction>;
-    initiateRecovery(params: InitiateRecoveryOptions): never;
+    recoverXrpToken(params: any, tokenParams: any): Promise<RecoveryInfo | {
+        txHex: any;
+        coin: string;
+    }>;
     /**
      * Generate a new keypair for this coin.
      * @param seed Seed from which the new keypair should be generated, otherwise a random seed is used
      */
     generateKeyPair(seed?: Buffer): KeyPair;
     parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
+    /** @inheritDoc */
+    auditDecryptedKey(params: AuditDecryptedKeyParams): void;
 }
-export {};
 //# sourceMappingURL=xrp.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"xrp.d.ts","sourceRoot":"","sources":["../../src/xrp.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"xrp.d.ts","sourceRoot":"","sources":["../../src/xrp.ts"],"names":[],"mappings":"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"}