@bitgo-beta/sdk-coin-xrp 1.3.3-alpha.402 → 1.3.3-alpha.404

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

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+"use strict";
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsaUNBQThCO0FBQzlCLCtCQUE0QjtBQUM1Qix5Q0FBc0M7QUFFL0IsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFjLEVBQVEsRUFBRTtJQUMvQyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxTQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDeEMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzFDLG1CQUFRLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQ3ZFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBTlcsUUFBQSxRQUFRLFlBTW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHhycCB9IGZyb20gJy4vdHhycCc7XG5pbXBvcnQgeyBYcnAgfSBmcm9tICcuL3hycCc7XG5pbXBvcnQgeyBYcnBUb2tlbiB9IGZyb20gJy4veHJwVG9rZW4nO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCd4cnAnLCBYcnAuY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3R4cnAnLCBUeHJwLmNyZWF0ZUluc3RhbmNlKTtcbiAgWHJwVG9rZW4uY3JlYXRlVG9rZW5Db25zdHJ1Y3RvcnMoKS5mb3JFYWNoKCh7IG5hbWUsIGNvaW5Db25zdHJ1Y3RvciB9KSA9PiB7XG4gICAgc2RrLnJlZ2lzdGVyKG5hbWUsIGNvaW5Db25zdHJ1Y3Rvcik7XG4gIH0pO1xufTtcbiJdfQ==

package/dist/src/ripple.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @hidden
+ */
+/**
+ */
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * @hidden
+ */
+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 };
+};
+/**
+ */
+const rippleKeypairs = __importStar(require("ripple-keypairs"));
+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"));
+/**
+ * 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);
+}
+/**
+ * Sign Ripple transaction with a secp256k1 private key
+ * @param txHex
+ * @param privateKey
+ * @param options
+ * @returns {{signedTransaction: *, id}}
+ */
+const signWithPrivateKey = function (txHex, privateKey, options) {
+    let privateKeyBuffer = Buffer.from(privateKey, 'hex');
+    if (privateKeyBuffer.length === 33 && privateKeyBuffer[0] === 0) {
+        privateKeyBuffer = privateKeyBuffer.slice(1, 33);
+    }
+    const publicKey = secp256k1_1.ECPair.fromPrivateKey(privateKeyBuffer).publicKey.toString('hex').toUpperCase();
+    let tx;
+    try {
+        tx = binary.decode(txHex);
+    }
+    catch (e) {
+        try {
+            tx = JSON.parse(txHex);
+        }
+        catch (e) {
+            throw new Error('txHex needs to be either hex or JSON string for XRP');
+        }
+    }
+    tx.SigningPubKey = options && options.signAs ? '' : publicKey;
+    if (options && options.signAs) {
+        const expectedSigner = rippleKeypairs.deriveAddress(publicKey);
+        if (options.signAs !== expectedSigner) {
+            throw new Error('signAs does not match private key');
+        }
+        const signer = {
+            Account: options.signAs,
+            SigningPubKey: publicKey,
+            TxnSignature: computeSignature(tx, privateKey, options.signAs),
+        };
+        // 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);
+    }
+    const serialized = binary.encode(tx);
+    return {
+        signedTransaction: serialized,
+        id: xrpl.hashes.hashSignedTx(serialized),
+    };
+};
+module.exports = { ...xrpl, signWithPrivateKey };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/txrp.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Testnet XRP
+ *
+ * @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, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+    /**
+     * Identifier for the blockchain which supports this coin
+     */
+    getChain(): string;
+    /**
+     * URL of a well-known, public facing (non-bitgo) rippled instance which can be used for recovery
+     */
+    getRippledUrl(): string;
+    /**
+     * Complete human-readable name of this coin
+     */
+    getFullName(): string;
+}
+//# sourceMappingURL=txrp.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Txrp = void 0;
+const xrp_1 = require("./xrp");
+class Txrp extends xrp_1.Xrp {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Txrp(bitgo, staticsCoin);
+    }
+    /**
+     * Identifier for the blockchain which supports this coin
+     */
+    getChain() {
+        return 'txrp';
+    }
+    /**
+     * URL of a well-known, public facing (non-bitgo) rippled instance which can be used for recovery
+     */
+    getRippledUrl() {
+        return 'https://s.altnet.rippletest.net:51234';
+    }
+    /**
+     * Complete human-readable name of this coin
+     */
+    getFullName() {
+        return 'Testnet Ripple';
+    }
+}
+exports.Txrp = Txrp;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/xrp.d.ts

@@ -0,0 +1,116 @@
+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 _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
+     */
+    getBaseFactor(): number;
+    /**
+     * Identifier for the blockchain which supports this coin
+     */
+    getChain(): string;
+    /**
+     * Identifier for the coin family
+     */
+    getFamily(): string;
+    /**
+     * Complete human-readable name of this coin
+     */
+    getFullName(): string;
+    /**
+     * Evaluates whether an address string is valid for this coin
+     * @param address
+     */
+    isValidAddress(address: string): boolean;
+    /**
+     * Return boolean indicating whether input is valid public key for the coin.
+     *
+     * @param {String} pub the pub to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidPub(pub: string): boolean;
+    /**
+     * 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
+     * - txPrebuild
+     * - prv
+     * @returns Bluebird<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
+     * @param walletParams
+     * - rootPrivateKey: optional hex-encoded Ripple private key
+     */
+    supplementGenerateWallet(walletParams: SupplementGenerateWalletOptions): Promise<SupplementGenerateWalletOptions>;
+    /**
+     * Explain/parse transaction
+     * @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
+     * @param txPrebuild prebuild object returned by server
+     * @param wallet
+     * @returns {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
+     * @param address {String} the address to verify
+     * @param rootAddress {String} the wallet's root address
+     * @return true iff address is a wallet address (based on rootAddress)
+     */
+    isWalletAddress({ address, rootAddress }: VerifyAddressOptions): Promise<boolean>;
+    /**
+     * URL of a well-known, public facing (non-bitgo) rippled instance which can be used for recovery
+     */
+    getRippledUrl(): string;
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     * - rootAddress: root XRP wallet address to recover funds from
+     * - userKey: [encrypted] xprv
+     * - backupKey: [encrypted] xprv, or xpub if the xprv is held by a KRS provider
+     * - walletPassphrase: necessary if one of the xprvs is encrypted
+     * - bitgoKey: xpub
+     * - krsProvider: necessary if backup key is held by KRS
+     * - recoveryDestination: target address to send recovered funds to
+     */
+    recover(params: RecoveryOptions): Promise<RecoveryInfo | RecoveryTransaction>;
+    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;
+}
+//# sourceMappingURL=xrp.d.ts.map

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

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