@bitgo/sdk-coin-avaxp 0.2.0-dev.1 → 1.0.1-rc.2

package/dist/src/lib/utils.js

@@ -0,0 +1,257 @@
+"use strict";
+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]; } });
+}) : (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 });
+exports.Utils = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const avalanche_1 = require("avalanche");
+const utils_1 = require("avalanche/dist/utils");
+const elliptic_1 = require("elliptic");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const keychain_1 = require("avalanche/dist/apis/platformvm/keychain");
+const common_1 = require("avalanche/dist/common");
+const createHash = __importStar(require("create-hash"));
+class Utils {
+    constructor() {
+        this.binTools = avalanche_1.BinTools.getInstance();
+        this.cb58Decode = this.binTools.cb58Decode;
+        this.cb58Encode = this.binTools.cb58Encode;
+        this.stringToBuffer = this.binTools.stringToBuffer;
+        this.bufferToString = this.binTools.bufferToString;
+        this.NodeIDStringToBuffer = utils_1.NodeIDStringToBuffer;
+        this.addressToString = this.binTools.addressToString;
+        this.parseAddress = (pub) => this.binTools.parseAddress(pub, 'P');
+    }
+    includeIn(walletAddresses, otxoOutputAddresses) {
+        return walletAddresses.map((a) => otxoOutputAddresses.includes(a)).reduce((a, b) => a && b, true);
+    }
+    /**
+     * Checks if it is a valid address no illegal characters
+     *
+     * @param {string} address - address to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidAddress(address) {
+        return address.match(/^[a-zA-Z0-9]+$/) !== null;
+    }
+    /**
+     * Checks if it is a valid blockId with length 66 including 0x
+     *
+     * @param {string} hash - blockId to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidBlockId(hash) {
+        if (hash.length !== 66 || hash.slice(0, 2) !== '0x') {
+            return false;
+        }
+        return hash.match(/^[a-zA-Z0-9]+$/) !== null;
+    }
+    /**
+     * Checks if the string is a valid protocol public key or
+     * extended public key.
+     *
+     * @param {string} pub - the  public key to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPublicKey(pub) {
+        if (sdk_core_1.isValidXpub(pub))
+            return true;
+        let pubBuf;
+        if (pub.length === 50) {
+            try {
+                pubBuf = utils.cb58Decode(pub);
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            if (pub.length !== 66 && pub.length !== 130)
+                return false;
+            const firstByte = pub.slice(0, 2);
+            // uncompressed public key
+            if (pub.length === 130 && firstByte !== '04')
+                return false;
+            // compressed public key
+            if (pub.length === 66 && firstByte !== '02' && firstByte !== '03')
+                return false;
+            if (!this.allHexChars(pub))
+                return false;
+            pubBuf = avalanche_1.Buffer.from(pub, 'hex');
+        }
+        // validate the public key
+        const secp256k1 = new elliptic_1.ec('secp256k1');
+        try {
+            const keyPair = secp256k1.keyFromPublic(pubBuf);
+            const { result } = keyPair.validate();
+            return result;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Returns whether or not the string is a valid protocol private key, or extended
+     * private key.
+     *
+     * The protocol key format is described in the @stacks/transactions npm package, in the
+     * createStacksPrivateKey function:
+     * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125
+     *
+     * @param {string} prv - the private key (or extended private key) to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPrivateKey(prv) {
+        if (sdk_core_1.isValidXprv(prv))
+            return true;
+        if (prv.length !== 64 && prv.length !== 66)
+            return false;
+        if (prv.length === 66 && prv.slice(64) !== '01')
+            return false;
+        return this.allHexChars(prv);
+    }
+    /**
+     * Returns whether or not the string is a composed of hex chars only
+     *
+     * @param {string} maybe - the  string to be validated
+     * @returns {boolean} - the validation result
+     */
+    allHexChars(maybe) {
+        return /^([0-9a-f])+$/i.test(maybe);
+    }
+    /** @inheritdoc */
+    isValidSignature(signature) {
+        throw new sdk_core_1.NotImplementedError('isValidSignature not implemented');
+    }
+    /** @inheritdoc */
+    isValidTransactionId(txId) {
+        throw new sdk_core_1.NotImplementedError('isValidTransactionId not implemented');
+    }
+    getCredentials(tx) {
+        return tx.getIns().map((ins) => platformvm_1.SelectCredentialClass(ins.getInput().getCredentialID()));
+    }
+    from(raw) {
+        const tx = new platformvm_1.Tx();
+        try {
+            tx.fromString(raw);
+            return tx;
+        }
+        catch (err) {
+            const utx = new platformvm_1.UnsignedTx();
+            utx.fromBuffer(utils.cb58Decode(raw));
+            return new platformvm_1.Tx(utx, []);
+        }
+    }
+    /**
+     * Avaxp wrapper to create signature and return it for credentials using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignatureAvaxBuffer(network, message, prv) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        ky.importKey(prv);
+        return ky.sign(message);
+    }
+    /**
+     * Avaxp wrapper to create signature and return it for credentials
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignature(network, message, prv) {
+        return Buffer.from(this.createSignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(prv)));
+    }
+    /**
+     * Avaxp wrapper to verify signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignatureAvaxBuffer(network, message, signature, prv) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        ky.importKey(prv);
+        return ky.verify(message, signature);
+    }
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignature(network, message, signature, prv) {
+        return this.verifySignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(signature), avalanche_1.Buffer.from(prv));
+    }
+    createSig(sigHex) {
+        const sig = new common_1.Signature();
+        sig.fromBuffer(avalanche_1.Buffer.from(sigHex.padStart(130, '0'), 'hex'));
+        return sig;
+    }
+    /**
+     * Avaxp wrapper to recovery signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @return
+     */
+    recoverySignatureAvaxBuffer(network, message, signature) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        return ky.recover(message, signature);
+    }
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @return true if it's verify successful
+     */
+    recoverySignature(network, message, signature) {
+        return Buffer.from(this.recoverySignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(signature)));
+    }
+    sha256(buf) {
+        return createHash.default('sha256').update(buf).digest();
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     * It's to reuse in TransactionBuilder and TransactionBuilderFactory
+     *
+     * @param rawTransaction Transaction as hex string
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Raw transaction is empty');
+        }
+        if (!utils.allHexChars(rawTransaction)) {
+            throw new sdk_core_1.ParseTransactionError('Raw transaction is not hex string');
+        }
+    }
+}
+exports.Utils = Utils;
+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":";;;;;;;;;;;;;;;;;;;;;;AAAA,8CAOyB;AACzB,yCAA2D;AAC3D,gDAA4D;AAC5D,uCAA8B;AAC9B,+DAA+F;AAE/F,sEAAiF;AAEjF,kDAAkD;AAClD,wDAA0C;AAE1C,MAAa,KAAK;IAAlB;QACU,aAAQ,GAAG,oBAAQ,CAAC,WAAW,EAAE,CAAC;QACnC,eAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;QACtC,eAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;QACtC,mBAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;QAC9C,mBAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;QAC9C,yBAAoB,GAAG,4BAAoB,CAAC;QAC5C,oBAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC;QAyEhD,iBAAY,GAAG,CAAC,GAAW,EAAc,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAsK1F,CAAC;IA7OQ,SAAS,CAAC,eAAyB,EAAE,mBAA6B;QACvE,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IACpG,CAAC;IAED;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,OAAe;QAC5B,OAAQ,OAAkB,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,IAAY;QACzB,IAAI,IAAI,CAAC,MAAM,KAAK,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE;YACnD,OAAO,KAAK,CAAC;SACd;QACD,OAAQ,IAAe,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IAC3D,CAAC;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,GAAW;QAC1B,IAAI,sBAAW,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;QAElC,IAAI,MAAM,CAAC;QACX,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,EAAE;YACrB,IAAI;gBACF,MAAM,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;aAChC;YAAC,MAAM;gBACN,OAAO,KAAK,CAAC;aACd;SACF;aAAM;YACL,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG;gBAAE,OAAO,KAAK,CAAC;YAE1D,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAElC,0BAA0B;YAC1B,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,SAAS,KAAK,IAAI;gBAAE,OAAO,KAAK,CAAC;YAE3D,wBAAwB;YACxB,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI;gBAAE,OAAO,KAAK,CAAC;YAEhF,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YAEzC,MAAM,GAAG,kBAAU,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;SACtC;QACD,0BAA0B;QAC1B,MAAM,SAAS,GAAG,IAAI,aAAE,CAAC,WAAW,CAAC,CAAC;QACtC,IAAI;YACF,MAAM,OAAO,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACtC,OAAO,MAAM,CAAC;SACf;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAGD;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,GAAW;QAC3B,IAAI,sBAAW,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;QAElC,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE;YAAE,OAAO,KAAK,CAAC;QAEzD,IAAI,GAAG,CAAC,MAAM,KAAK,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAE9D,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,KAAa;QACvB,OAAO,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,kBAAkB;IAClB,gBAAgB,CAAC,SAAiB;QAChC,MAAM,IAAI,8BAAmB,CAAC,kCAAkC,CAAC,CAAC;IACpE,CAAC;IAED,kBAAkB;IAClB,oBAAoB,CAAC,IAAY;QAC/B,MAAM,IAAI,8BAAmB,CAAC,sCAAsC,CAAC,CAAC;IACxE,CAAC;IAED,cAAc,CAAC,EAAU;QACvB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,kCAAqB,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAC3F,CAAC;IAED,IAAI,CAAC,GAAW;QACd,MAAM,EAAE,GAAG,IAAI,eAAE,EAAE,CAAC;QACpB,IAAI;YACF,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YACnB,OAAO,EAAE,CAAC;SACX;QAAC,OAAO,GAAG,EAAE;YACZ,MAAM,GAAG,GAAG,IAAI,uBAAU,EAAE,CAAC;YAC7B,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;YACtC,OAAO,IAAI,eAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;SACxB;IACH,CAAC;IAED;;;;;;OAMG;IACH,yBAAyB,CAAC,OAAyB,EAAE,OAAmB,EAAE,GAAe;QACvF,MAAM,EAAE,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClB,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,OAAyB,EAAE,OAAe,EAAE,GAAW;QACrE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,OAAO,EAAE,kBAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,kBAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC9G,CAAC;IAED;;;;;;;OAOG;IACH,yBAAyB,CACvB,OAAyB,EACzB,OAAmB,EACnB,SAAqB,EACrB,GAAe;QAEf,MAAM,EAAE,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClB,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,OAAyB,EAAE,OAAe,EAAE,SAAiB,EAAE,GAAW;QACxF,OAAO,IAAI,CAAC,yBAAyB,CACnC,OAAO,EACP,kBAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EACxB,kBAAU,CAAC,IAAI,CAAC,SAAS,CAAC,EAC1B,kBAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CACrB,CAAC;IACJ,CAAC;IAED,SAAS,CAAC,MAAc;QACtB,MAAM,GAAG,GAAG,IAAI,kBAAS,EAAE,CAAC;QAC5B,GAAG,CAAC,UAAU,CAAC,kBAAU,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAClE,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;OAMG;IACH,2BAA2B,CAAC,OAAyB,EAAE,OAAmB,EAAE,SAAqB;QAC/F,MAAM,EAAE,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtE,OAAO,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACH,iBAAiB,CAAC,OAAyB,EAAE,OAAe,EAAE,SAAiB;QAC7E,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,kBAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,kBAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACtH,CAAC;IAED,MAAM,CAAC,GAAe;QACpB,OAAO,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACH,sBAAsB,CAAC,cAAsB;QAC3C,IAAI,CAAC,cAAc,EAAE;YACnB,MAAM,IAAI,kCAAuB,CAAC,0BAA0B,CAAC,CAAC;SAC/D;QACD,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE;YACtC,MAAM,IAAI,gCAAqB,CAAC,mCAAmC,CAAC,CAAC;SACtE;IACH,CAAC;CACF;AAtPD,sBAsPC;AAED,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;AAE1B,kBAAe,KAAK,CAAC","sourcesContent":["import {\n  isValidXpub,\n  isValidXprv,\n  NotImplementedError,\n  BaseUtils,\n  InvalidTransactionError,\n  ParseTransactionError,\n} from '@bitgo/sdk-core';\nimport { BinTools, Buffer as BufferAvax } from 'avalanche';\nimport { NodeIDStringToBuffer } from 'avalanche/dist/utils';\nimport { ec } from 'elliptic';\nimport { BaseTx, SelectCredentialClass, Tx, UnsignedTx } from 'avalanche/dist/apis/platformvm';\nimport { Credential } from 'avalanche/dist/common/credentials';\nimport { KeyPair as KeyPairAvax } from 'avalanche/dist/apis/platformvm/keychain';\nimport { AvalancheNetwork } from '@bitgo/statics';\nimport { Signature } from 'avalanche/dist/common';\nimport * as createHash from 'create-hash';\n\nexport class Utils implements BaseUtils {\n  private binTools = BinTools.getInstance();\n  public cb58Decode = this.binTools.cb58Decode;\n  public cb58Encode = this.binTools.cb58Encode;\n  public stringToBuffer = this.binTools.stringToBuffer;\n  public bufferToString = this.binTools.bufferToString;\n  public NodeIDStringToBuffer = NodeIDStringToBuffer;\n  public addressToString = this.binTools.addressToString;\n\n  public includeIn(walletAddresses: string[], otxoOutputAddresses: string[]): boolean {\n    return walletAddresses.map((a) => otxoOutputAddresses.includes(a)).reduce((a, b) => a && b, true);\n  }\n\n  /**\n   * Checks if it is a valid address no illegal characters\n   *\n   * @param {string} address - address to be validated\n   * @returns {boolean} - the validation result\n   */\n  /** @inheritdoc */\n  isValidAddress(address: string): boolean {\n    return (address as string).match(/^[a-zA-Z0-9]+$/) !== null;\n  }\n\n  /**\n   * Checks if it is a valid blockId with length 66 including 0x\n   *\n   * @param {string} hash - blockId to be validated\n   * @returns {boolean} - the validation result\n   */\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    if (hash.length !== 66 || hash.slice(0, 2) !== '0x') {\n      return false;\n    }\n    return (hash as string).match(/^[a-zA-Z0-9]+$/) !== null;\n  }\n\n  /**\n   * Checks if the string is a valid protocol public key or\n   * extended public key.\n   *\n   * @param {string} pub - the  public key to be validated\n   * @returns {boolean} - the validation result\n   */\n  isValidPublicKey(pub: string): boolean {\n    if (isValidXpub(pub)) return true;\n\n    let pubBuf;\n    if (pub.length === 50) {\n      try {\n        pubBuf = utils.cb58Decode(pub);\n      } catch {\n        return false;\n      }\n    } else {\n      if (pub.length !== 66 && pub.length !== 130) return false;\n\n      const firstByte = pub.slice(0, 2);\n\n      // uncompressed public key\n      if (pub.length === 130 && firstByte !== '04') return false;\n\n      // compressed public key\n      if (pub.length === 66 && firstByte !== '02' && firstByte !== '03') return false;\n\n      if (!this.allHexChars(pub)) return false;\n\n      pubBuf = BufferAvax.from(pub, 'hex');\n    }\n    // validate the public key\n    const secp256k1 = new ec('secp256k1');\n    try {\n      const keyPair = secp256k1.keyFromPublic(pubBuf);\n      const { result } = keyPair.validate();\n      return result;\n    } catch (e) {\n      return false;\n    }\n  }\n  public parseAddress = (pub: string): BufferAvax => this.binTools.parseAddress(pub, 'P');\n\n  /**\n   * Returns whether or not the string is a valid protocol private key, or extended\n   * private key.\n   *\n   * The protocol key format is described in the @stacks/transactions npm package, in the\n   * createStacksPrivateKey function:\n   * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125\n   *\n   * @param {string} prv - the private key (or extended private key) to be validated\n   * @returns {boolean} - the validation result\n   */\n  isValidPrivateKey(prv: string): boolean {\n    if (isValidXprv(prv)) return true;\n\n    if (prv.length !== 64 && prv.length !== 66) return false;\n\n    if (prv.length === 66 && prv.slice(64) !== '01') return false;\n\n    return this.allHexChars(prv);\n  }\n\n  /**\n   * Returns whether or not the string is a composed of hex chars only\n   *\n   * @param {string} maybe - the  string to be validated\n   * @returns {boolean} - the validation result\n   */\n  allHexChars(maybe: string): boolean {\n    return /^([0-9a-f])+$/i.test(maybe);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new NotImplementedError('isValidSignature not implemented');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    throw new NotImplementedError('isValidTransactionId not implemented');\n  }\n\n  getCredentials(tx: BaseTx): Credential[] {\n    return tx.getIns().map((ins) => SelectCredentialClass(ins.getInput().getCredentialID()));\n  }\n\n  from(raw: string): Tx {\n    const tx = new Tx();\n    try {\n      tx.fromString(raw);\n      return tx;\n    } catch (err) {\n      const utx = new UnsignedTx();\n      utx.fromBuffer(utils.cb58Decode(raw));\n      return new Tx(utx, []);\n    }\n  }\n\n  /**\n   * Avaxp wrapper to create signature and return it for credentials using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param prv\n   * @return signature\n   */\n  createSignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, prv: BufferAvax): BufferAvax {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    ky.importKey(prv);\n    return ky.sign(message);\n  }\n\n  /**\n   * Avaxp wrapper to create signature and return it for credentials\n   * @param network\n   * @param message\n   * @param prv\n   * @return signature\n   */\n  createSignature(network: AvalancheNetwork, message: Buffer, prv: Buffer): Buffer {\n    return Buffer.from(this.createSignatureAvaxBuffer(network, BufferAvax.from(message), BufferAvax.from(prv)));\n  }\n\n  /**\n   * Avaxp wrapper to verify signature using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param signature\n   * @param prv\n   * @return true if it's verify successful\n   */\n  verifySignatureAvaxBuffer(\n    network: AvalancheNetwork,\n    message: BufferAvax,\n    signature: BufferAvax,\n    prv: BufferAvax\n  ): boolean {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    ky.importKey(prv);\n    return ky.verify(message, signature);\n  }\n\n  /**\n   * Avaxp wrapper to verify signature\n   * @param network\n   * @param message\n   * @param signature\n   * @param prv\n   * @return true if it's verify successful\n   */\n  verifySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer, prv: Buffer): boolean {\n    return this.verifySignatureAvaxBuffer(\n      network,\n      BufferAvax.from(message),\n      BufferAvax.from(signature),\n      BufferAvax.from(prv)\n    );\n  }\n\n  createSig(sigHex: string): Signature {\n    const sig = new Signature();\n    sig.fromBuffer(BufferAvax.from(sigHex.padStart(130, '0'), 'hex'));\n    return sig;\n  }\n\n  /**\n   * Avaxp wrapper to recovery signature using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param signature\n   * @return\n   */\n  recoverySignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, signature: BufferAvax): BufferAvax {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    return ky.recover(message, signature);\n  }\n\n  /**\n   * Avaxp wrapper to verify signature\n   * @param network\n   * @param message\n   * @param signature\n   * @return true if it's verify successful\n   */\n  recoverySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer): Buffer {\n    return Buffer.from(this.recoverySignatureAvaxBuffer(network, BufferAvax.from(message), BufferAvax.from(signature)));\n  }\n\n  sha256(buf: Uint8Array): Buffer {\n    return createHash.default('sha256').update(buf).digest();\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   * It's to reuse in TransactionBuilder and TransactionBuilderFactory\n   *\n   * @param rawTransaction Transaction as hex string\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Raw transaction is empty');\n    }\n    if (!utils.allHexChars(rawTransaction)) {\n      throw new ParseTransactionError('Raw transaction is not hex string');\n    }\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/dist/src/{validatorTxBuilder.d.ts → lib/validatorTxBuilder.d.ts}

@@ -1,12 +1,18 @@
 import { DelegatorTxBuilder } from './delegatorTxBuilder';
 import { BaseCoin } from '@bitgo/statics';
-import { BaseTx } from 'avalanche/dist/apis/platformvm';
+import { AddValidatorTx, BaseTx, Tx } from 'avalanche/dist/apis/platformvm';
+import { TransactionType } from '@bitgo/sdk-core';
 export declare class ValidatorTxBuilder extends DelegatorTxBuilder {
     protected _delegationFeeRate: number;
     /**
      * @param coinConfig
      */
     constructor(coinConfig: Readonly<BaseCoin>);
+    /**
+     * get transaction type
+     * @protected
+     */
+    protected get transactionType(): TransactionType;
     /**
      * set the delegationFeeRate
      * @param value BigInt
@@ -22,11 +28,13 @@ export declare class ValidatorTxBuilder extends DelegatorTxBuilder {
      * @param tx BaseTx
      * @returns ValidatorTxBuilder
      */
-    initBuilder(tx?: BaseTx): this;
+    initBuilder(tx: Tx): this;
+    static verifyTxType(baseTx: BaseTx): baseTx is AddValidatorTx;
+    verifyTxType(baseTx: BaseTx): baseTx is AddValidatorTx;
     /**
      * Build the validator transaction
      * @protected
      */
-    protected buildAvaxpTransaction(): BaseTx;
+    protected buildAvaxpTransaction(): void;
 }
 //# sourceMappingURL=validatorTxBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validatorTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/validatorTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,EAAuB,EAAE,EAAc,MAAM,gCAAgC,CAAC;AAC7G,OAAO,EAAuC,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvF,qBAAa,kBAAmB,SAAQ,kBAAkB;IACxD,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAErC;;OAEG;gBACS,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAI1C;;;OAGG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;OAGG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACH,yBAAyB,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI;IAQ1D;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAUzB,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,cAAc;IAI7D,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,cAAc;IAItD;;;OAGG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;CAwBxC"}

package/dist/src/lib/validatorTxBuilder.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorTxBuilder = void 0;
+const delegatorTxBuilder_1 = require("./delegatorTxBuilder");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+class ValidatorTxBuilder extends delegatorTxBuilder_1.DelegatorTxBuilder {
+    /**
+     * @param coinConfig
+     */
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    /**
+     * get transaction type
+     * @protected
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.addValidator;
+    }
+    /**
+     * set the delegationFeeRate
+     * @param value BigInt
+     */
+    delegationFeeRate(value) {
+        this.validateDelegationFeeRate(value);
+        this._delegationFeeRate = value;
+        return this;
+    }
+    /**
+     * Validate that the delegation fee is at least the minDelegationFee
+     * @param delegationFeeRate BigInt
+     */
+    validateDelegationFeeRate(delegationFeeRate) {
+        if (delegationFeeRate < this.transaction._network.minDelegationFee) {
+            throw new sdk_core_1.BuildTransactionError(`Delegation fee cannot be less than ${this.transaction._network.minDelegationFee}`);
+        }
+    }
+    /**
+     * Initialize the builder
+     * @param tx BaseTx
+     * @returns ValidatorTxBuilder
+     */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const baseTx = tx.getUnsignedTx().getTransaction();
+        if (!this.verifyTxType(baseTx)) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        this._delegationFeeRate = baseTx.getDelegationFee();
+        return this;
+    }
+    static verifyTxType(baseTx) {
+        return baseTx.getTypeID() === platformvm_1.PlatformVMConstants.ADDVALIDATORTX;
+    }
+    verifyTxType(baseTx) {
+        return ValidatorTxBuilder.verifyTxType(baseTx);
+    }
+    /**
+     * Build the validator transaction
+     * @protected
+     */
+    buildAvaxpTransaction() {
+        const { inputs, outputs, credentials } = this.createInputOutput();
+        this.transaction.setTransaction(new platformvm_1.Tx(new platformvm_1.UnsignedTx(new platformvm_1.AddValidatorTx(this.transaction._networkID, this.transaction._blockchainID, outputs, inputs, this.transaction._memo, utils_1.default.NodeIDStringToBuffer(this._nodeID), this._startTime, this._endTime, this._stakeAmount, [this.stakeTransferOut()], this.rewardOwnersOutput(), this._delegationFeeRate)), credentials));
+    }
+}
+exports.ValidatorTxBuilder = ValidatorTxBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/tavaxp.d.ts

@@ -0,0 +1,9 @@
+import { BaseCoin, BitGoBase } from '@bitgo/sdk-core';
+import { AvaxP } from './avaxp';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+export declare class TavaxP extends AvaxP {
+    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+}
+//# sourceMappingURL=tavaxp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tavaxp.d.ts","sourceRoot":"","sources":["../../src/tavaxp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAE7D,qBAAa,MAAO,SAAQ,KAAK;IAC/B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;gBAE/C,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIrE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;CAG3F"}

package/dist/src/tavaxp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavaxP = void 0;
+const avaxp_1 = require("./avaxp");
+class TavaxP extends avaxp_1.AvaxP {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new TavaxP(bitgo, staticsCoin);
+    }
+}
+exports.TavaxP = TavaxP;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGF2YXhwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RhdmF4cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxtQ0FBZ0M7QUFHaEMsTUFBYSxNQUFPLFNBQVEsYUFBSztJQUcvQixZQUFZLEtBQWdCLEVBQUUsV0FBdUM7UUFDbkUsS0FBSyxDQUFDLEtBQUssRUFBRSxXQUFXLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRUQsTUFBTSxDQUFDLGNBQWMsQ0FBQyxLQUFnQixFQUFFLFdBQXVDO1FBQzdFLE9BQU8sSUFBSSxNQUFNLENBQUMsS0FBSyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7Q0FDRjtBQVZELHdCQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUNvaW4sIEJpdEdvQmFzZSB9IGZyb20gJ0BiaXRnby9zZGstY29yZSc7XG5pbXBvcnQgeyBBdmF4UCB9IGZyb20gJy4vYXZheHAnO1xuaW1wb3J0IHsgQmFzZUNvaW4gYXMgU3RhdGljc0Jhc2VDb2luIH0gZnJvbSAnQGJpdGdvL3N0YXRpY3MnO1xuXG5leHBvcnQgY2xhc3MgVGF2YXhQIGV4dGVuZHMgQXZheFAge1xuICBwcm90ZWN0ZWQgcmVhZG9ubHkgX3N0YXRpY3NDb2luOiBSZWFkb25seTxTdGF0aWNzQmFzZUNvaW4+O1xuXG4gIGNvbnN0cnVjdG9yKGJpdGdvOiBCaXRHb0Jhc2UsIHN0YXRpY3NDb2luPzogUmVhZG9ubHk8U3RhdGljc0Jhc2VDb2luPikge1xuICAgIHN1cGVyKGJpdGdvLCBzdGF0aWNzQ29pbik7XG4gIH1cblxuICBzdGF0aWMgY3JlYXRlSW5zdGFuY2UoYml0Z286IEJpdEdvQmFzZSwgc3RhdGljc0NvaW4/OiBSZWFkb25seTxTdGF0aWNzQmFzZUNvaW4+KTogQmFzZUNvaW4ge1xuICAgIHJldHVybiBuZXcgVGF2YXhQKGJpdGdvLCBzdGF0aWNzQ29pbik7XG4gIH1cbn1cbiJdfQ==