@bitgo/sdk-coin-avaxp 2.1.0 → 2.2.0-hotfix.0

package/dist/src/transaction.js

@@ -0,0 +1,160 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const keyPair_1 = require("./keyPair");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+const createHash = __importStar(require("create-hash"));
+const common_1 = require("avalanche/dist/common");
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._credentials = [];
+        this._threshold = 2;
+        this._locktime = new avalanche_1.BN(0);
+        this._fromPubKeys = [];
+        this._utxos = [];
+        this._network = coinConfig.network;
+        this._assetId = utils_1.default.cb58Decode(this._network.avaxAssetID);
+        this._blockchainID = utils_1.default.cb58Decode(this._network.blockchainID);
+        this._networkID = this._network.networkID;
+        this._txFee = new avalanche_1.BN(this._network.txFee.toString());
+    }
+    get avaxPTransaction() {
+        return this._avaxpTransaction.getTransaction();
+    }
+    set avaxPTransaction(tx) {
+        this._avaxpTransaction = new platformvm_1.UnsignedTx(tx);
+    }
+    set credentials(credentials) {
+        this._credentials = credentials;
+    }
+    get credentials() {
+        return this._credentials;
+    }
+    get hasCredentials() {
+        return this._credentials !== undefined && this._credentials.length > 0;
+    }
+    /** @inheritdoc */
+    canSign({ key }) {
+        try {
+            const kp = new keyPair_1.KeyPair({ prv: key });
+            const privateKey = kp.getPrivateKey();
+            if (!privateKey)
+                return false;
+            const address = utils_1.default.parseAddress(kp.getAddress(this._network.hrp));
+            return this._fromPubKeys.find((a) => address.equals(a)) !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Sign a avaxp transaction and update the transaction hex
+     * validator, delegator, import, exports extend baseTx
+     * unsignedTx: UnsignedTx = new UnsignedTx(baseTx)  (baseTx = addValidatorTx)
+     * const tx: Tx = unsignedTx.sign(keychain) (tx is type standard signed tx)
+     * get baseTx then create new unsignedTx then sign
+     *
+     * @param {KeyPair} keyPair
+     */
+    sign(keyPair) {
+        const prv = keyPair.getPrivateKey();
+        if (!prv) {
+            throw new sdk_core_1.SigningError('Missing private key');
+        }
+        if (!this.avaxPTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('empty transaction to sign');
+        }
+        if (!this.hasCredentials) {
+            throw new sdk_core_1.InvalidTransactionError('empty credentials to sign');
+        }
+        const signature = this.createSignature(prv);
+        this._credentials.forEach((credential) => credential.addSignature(signature));
+    }
+    /** @inheritdoc */
+    /**
+     * should be of signedTx doing this with baseTx
+     */
+    toBroadcastFormat() {
+        if (!this.avaxPTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        const buffer = this.hasCredentials
+            ? new platformvm_1.Tx(this._avaxpTransaction, this._credentials).toBuffer()
+            : this._avaxpTransaction.toBuffer();
+        const txSerialized = utils_1.default.cb58Encode(buffer).toString();
+        return txSerialized;
+    }
+    // types - stakingTransaction, import, export
+    toJson() {
+        if (!this.avaxPTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        return {
+            blockchain_id: utils_1.default.cb58Encode(this.avaxPTransaction.getBlockchainID()),
+            network_id: this.avaxPTransaction.getNetworkID(),
+            inputs: this.avaxPTransaction.getIns(),
+            outputs: this.avaxPTransaction.getOuts(),
+            memo: utils_1.default.bufferToString(this.avaxPTransaction.getMemo()),
+            typeID: this.avaxPTransaction.getTxType(),
+        };
+    }
+    setTransaction(tx) {
+        this._avaxpTransaction = tx;
+    }
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType) {
+        this._type = transactionType;
+    }
+    /**
+     * Returns the portion of the transaction that needs to be signed in Buffer format.
+     * Only needed for coins that support adding signatures directly (e.g. TSS).
+     */
+    get signablePayload() {
+        const txbuff = this._avaxpTransaction.toBuffer();
+        return createHash.default('sha256').update(txbuff).digest();
+    }
+    /**
+     * Avax wrapper to create signature and return it for credentials
+     * @param prv
+     */
+    createSignature(prv) {
+        const ky = new platformvm_1.KeyPair(this._network.hrp, this._network.networkID.toString());
+        ky.importKey(avalanche_1.Buffer.from(prv));
+        const signval = ky.sign(avalanche_1.Buffer.from(this.signablePayload));
+        const sig = new common_1.Signature();
+        sig.fromBuffer(signval);
+        return sig;
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, AvalancheNetwork } from '@bitgo/statics';\nimport { BaseKey, SigningError, BaseTransaction, TransactionType, InvalidTransactionError } from '@bitgo/sdk-core';\nimport { KeyPair } from './keyPair';\nimport { DecodedUtxoObj, TxData } from './iface';\nimport { UnsignedTx, BaseTx, KeyPair as KeyPairAvax, Tx } from 'avalanche/dist/apis/platformvm';\nimport { BN, Buffer as BufferAvax } from 'avalanche';\nimport utils from './utils';\nimport * as createHash from 'create-hash';\nimport { Credential, Signature } from 'avalanche/dist/common';\n\nexport class Transaction extends BaseTransaction {\n  protected _avaxpTransaction: UnsignedTx;\n  private _credentials: Credential[] = [];\n  public _type: TransactionType;\n  public _network: AvalancheNetwork;\n  public _networkID: number;\n  public _assetId: BufferAvax;\n  public _blockchainID: BufferAvax;\n  public _memo?: BufferAvax;\n  public _threshold = 2;\n  public _locktime: BN = new BN(0);\n  public _fromPubKeys: BufferAvax[] = [];\n  public _utxos: DecodedUtxoObj[] = [];\n  public _txFee: BN;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._network = coinConfig.network as AvalancheNetwork;\n    this._assetId = utils.cb58Decode(this._network.avaxAssetID);\n    this._blockchainID = utils.cb58Decode(this._network.blockchainID);\n    this._networkID = this._network.networkID;\n    this._txFee = new BN(this._network.txFee.toString());\n  }\n\n  get avaxPTransaction(): BaseTx {\n    return this._avaxpTransaction.getTransaction();\n  }\n\n  set avaxPTransaction(tx: BaseTx) {\n    this._avaxpTransaction = new UnsignedTx(tx);\n  }\n\n  set credentials(credentials: Credential[]) {\n    this._credentials = credentials;\n  }\n\n  get credentials(): Credential[] {\n    return this._credentials;\n  }\n\n  get hasCredentials(): boolean {\n    return this._credentials !== undefined && this._credentials.length > 0;\n  }\n\n  /** @inheritdoc */\n  canSign({ key }: BaseKey): boolean {\n    try {\n      const kp = new KeyPair({ prv: key });\n      const privateKey = kp.getPrivateKey();\n      if (!privateKey) return false;\n      const address = utils.parseAddress(kp.getAddress(this._network.hrp));\n      return this._fromPubKeys.find((a) => address.equals(a)) !== undefined;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Sign a avaxp transaction and update the transaction hex\n   * validator, delegator, import, exports extend baseTx\n   * unsignedTx: UnsignedTx = new UnsignedTx(baseTx)  (baseTx = addValidatorTx)\n   * const tx: Tx = unsignedTx.sign(keychain) (tx is type standard signed tx)\n   * get baseTx then create new unsignedTx then sign\n   *\n   * @param {KeyPair} keyPair\n   */\n  sign(keyPair: KeyPair): void {\n    const prv = keyPair.getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Missing private key');\n    }\n    if (!this.avaxPTransaction) {\n      throw new InvalidTransactionError('empty transaction to sign');\n    }\n    if (!this.hasCredentials) {\n      throw new InvalidTransactionError('empty credentials to sign');\n    }\n    const signature = this.createSignature(prv);\n    this._credentials.forEach((credential) => credential.addSignature(signature));\n  }\n\n  /** @inheritdoc */\n  /**\n   * should be of signedTx doing this with baseTx\n   */\n  toBroadcastFormat(): string {\n    if (!this.avaxPTransaction) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    const buffer = this.hasCredentials\n      ? new Tx(this._avaxpTransaction, this._credentials).toBuffer()\n      : this._avaxpTransaction.toBuffer();\n    const txSerialized = utils.cb58Encode(buffer).toString();\n    return txSerialized;\n  }\n\n  // types - stakingTransaction, import, export\n  toJson(): TxData {\n    if (!this.avaxPTransaction) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    return {\n      blockchain_id: utils.cb58Encode(this.avaxPTransaction.getBlockchainID()),\n      network_id: this.avaxPTransaction.getNetworkID(),\n      inputs: this.avaxPTransaction.getIns(),\n      outputs: this.avaxPTransaction.getOuts(),\n      memo: utils.bufferToString(this.avaxPTransaction.getMemo()),\n      typeID: this.avaxPTransaction.getTxType(),\n    };\n  }\n\n  setTransaction(tx: UnsignedTx): void {\n    this._avaxpTransaction = tx;\n  }\n\n  /**\n   * Set the transaction type\n   *\n   * @param {TransactionType} transactionType The transaction type to be set\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  /**\n   * Returns the portion of the transaction that needs to be signed in Buffer format.\n   * Only needed for coins that support adding signatures directly (e.g. TSS).\n   */\n  get signablePayload(): Buffer {\n    const txbuff = this._avaxpTransaction.toBuffer();\n    return createHash.default('sha256').update(txbuff).digest();\n  }\n\n  /**\n   * Avax wrapper to create signature and return it for credentials\n   * @param prv\n   */\n  createSignature(prv: Buffer): Signature {\n    const ky = new KeyPairAvax(this._network.hrp, this._network.networkID.toString());\n    ky.importKey(BufferAvax.from(prv));\n    const signval = ky.sign(BufferAvax.from(this.signablePayload));\n    const sig = new Signature();\n    sig.fromBuffer(signval);\n    return sig;\n  }\n}\n"]}

package/dist/src/transactionBuilder.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="bn.js" />
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import BigNumber from 'bignumber.js';
+import { BaseAddress, BaseKey, BaseTransactionBuilder, TransactionType, BaseTransaction } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
+import { KeyPair } from './keyPair';
+import { BN } from 'avalanche';
+import { BaseTx } from 'avalanche/dist/apis/platformvm/basetx';
+import { Credential } from 'avalanche/dist/common';
+import { DecodedUtxoObj } from './iface';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    private _transaction;
+    _signer: KeyPair[];
+    protected recoverSigner: boolean;
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param recoverSigner
+     */
+    recoverMode(recoverSigner?: boolean): this;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * commented out check until multisig signing is in effect
+     * TODO: STLX-17077
+     * @param value
+     */
+    threshold(value: number): this;
+    locktime(value: string | number): this;
+    fromPubKey(senderPubKey: string | string[]): this;
+    utxos(value: DecodedUtxoObj[]): this;
+    /**
+     *
+     * @param value Optional Buffer for the memo
+     * @returns value Buffer for the memo
+     * set using Buffer.from("message")
+     */
+    memo(value: string): this;
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx?: BaseTx): this;
+    credentials(credentials: Credential[]): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    get hasSigner(): boolean;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Builds the avaxp transaction
+     * @return {Transaction} avaxp sdk transaction
+     */
+    protected abstract buildAvaxpTransaction(): BaseTx;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    protected set transaction(transaction: Transaction);
+    protected signImplementation({ key }: BaseKey): BaseTransaction;
+    protected abstract get transactionType(): TransactionType;
+    /**
+     * Validates the threshold
+     * @param threshold
+     */
+    validateThreshold(threshold: number): void;
+    /**
+     * Validates locktime
+     * @param locktime
+     */
+    validateLocktime(locktime: BN): void;
+    /** @inheritdoc */
+    validateAddress(address: BaseAddress, addressFormat?: string): void;
+    /** @inheritdoc */
+    validateKey({ key }: BaseKey): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    validateTransaction(transaction?: Transaction): void;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    validateUtxos(values: DecodedUtxoObj[]): void;
+    validateUtxo(value: DecodedUtxoObj): void;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../src/transactionBuilder.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAEL,WAAW,EACX,OAAO,EACP,sBAAsB,EACtB,eAAe,EAKf,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,OAAO,CAAC,YAAY,CAAc;IAC3B,OAAO,EAAE,OAAO,EAAE,CAAM;IAC/B,SAAS,CAAC,aAAa,UAAS;IAEhC;;;;OAIG;IACI,WAAW,CAAC,aAAa,UAAO,GAAG,IAAI;gBAKlC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;OAIG;IAEH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM9B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMtC,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAMjD,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAKpC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAqB9B,WAAW,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAK5C,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAIjE,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAgB3D;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,qBAAqB,IAAI,MAAM;IAGlD,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IACD,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;IAED,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,eAAe;IAK/D,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAM1D;;;OAGG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1C;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,EAAE,GAAG,IAAI;IAMpC,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;IAInE,kBAAkB;IAClB,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,IAAI;IAMnC,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAWpD,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAIpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI;IAO7C,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;CAO1C"}

package/dist/src/transactionBuilder.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transaction_1 = require("./transaction");
+const keyPair_1 = require("./keyPair");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signer = [];
+        this.recoverSigner = false;
+        this._transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param recoverSigner
+     */
+    recoverMode(recoverSigner = true) {
+        this.recoverSigner = recoverSigner;
+        return this;
+    }
+    /**
+     * commented out check until multisig signing is in effect
+     * TODO: STLX-17077
+     * @param value
+     */
+    threshold(value) {
+        // this.validateThreshold(value);
+        this._transaction._threshold = value;
+        return this;
+    }
+    locktime(value) {
+        this.validateLocktime(new avalanche_1.BN(value));
+        this._transaction._locktime = new avalanche_1.BN(value);
+        return this;
+    }
+    fromPubKey(senderPubKey) {
+        const pubKeys = senderPubKey instanceof Array ? senderPubKey : [senderPubKey];
+        this._transaction._fromPubKeys = pubKeys.map(utils_1.default.parseAddress);
+        return this;
+    }
+    utxos(value) {
+        this.validateUtxos(value);
+        this._transaction._utxos = value;
+        return this;
+    }
+    /**
+     *
+     * @param value Optional Buffer for the memo
+     * @returns value Buffer for the memo
+     * set using Buffer.from("message")
+     */
+    memo(value) {
+        this._transaction._memo = utils_1.default.stringToBuffer(value);
+        return this;
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx) {
+        if (!tx)
+            return this;
+        if (tx.getNetworkID() !== this._transaction._networkID ||
+            !tx.getBlockchainID().equals(this._transaction._blockchainID)) {
+            throw new Error('Network or blockchain is not equals');
+        }
+        this._transaction._memo = tx.getMemo();
+        const out = tx.getOuts()[0];
+        if (!out.getAssetID().equals(this._transaction._assetId)) {
+            throw new Error('AssetID are not equals');
+        }
+        const secpOut = out.getOutput();
+        this._transaction._locktime = secpOut.getLocktime();
+        this._transaction._threshold = secpOut.getThreshold();
+        this._transaction._fromPubKeys = secpOut.getAddresses();
+        this._transaction.avaxPTransaction = tx;
+        return this;
+    }
+    credentials(credentials) {
+        this.transaction.credentials = credentials;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        throw new sdk_core_1.NotSupported('from raw transaction is not supported. See TransactionBuilderFactory.from method');
+    }
+    get hasSigner() {
+        return this._signer !== undefined && this._signer.length > 0;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        // TODO: STLX-17317: sign with recovery key
+        // if (this.hasSigner) {
+        //    this.recoverSigner = this._fromPubKeys[1].equals(utils.parseAddress(this._signer[0].getAddress()));
+        // }
+        this.transaction.avaxPTransaction = this.buildAvaxpTransaction();
+        if (this.hasSigner) {
+            if (!this.transaction.hasCredentials) {
+                this.transaction.credentials = utils_1.default.getCredentials(this.transaction.avaxPTransaction);
+            }
+            this._signer.forEach((keyPair) => this.transaction.sign(keyPair));
+        }
+        this.transaction.setTransactionType(this.transactionType);
+        return this.transaction;
+    }
+    // region Getters and Setters
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    signImplementation({ key }) {
+        this._signer.push(new keyPair_1.KeyPair({ prv: key }));
+        return this.transaction;
+    }
+    // endregion
+    // region Validators
+    /**
+     * Validates the threshold
+     * @param threshold
+     */
+    validateThreshold(threshold) {
+        if (!threshold || threshold !== 2) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: threshold must be set to 2');
+        }
+    }
+    /**
+     * Validates locktime
+     * @param locktime
+     */
+    validateLocktime(locktime) {
+        if (!locktime || locktime.lt(new avalanche_1.BN(0))) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: locktime must be 0 or higher');
+        }
+    }
+    /** @inheritdoc */
+    validateAddress(address, addressFormat) {
+        throw new sdk_core_1.NotImplementedError('validateAddress not implemented');
+    }
+    /** @inheritdoc */
+    validateKey({ key }) {
+        if (!new keyPair_1.KeyPair({ prv: key })) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Raw transaction is empty');
+        }
+        try {
+            utils_1.default.cb58Decode(rawTransaction);
+        }
+        catch (e) {
+            throw new sdk_core_1.ParseTransactionError('Raw transaction is not hex string');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        // throw new NotImplementedError('validateTransaction not implemented');
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    validateUtxos(values) {
+        if (values.length === 0) {
+            throw new sdk_core_1.BuildTransactionError("Utxos can't be empty array");
+        }
+        values.forEach(this.validateUtxo);
+    }
+    validateUtxo(value) {
+        ['outputID', 'amount', 'txid', 'outputidx'].forEach((field) => {
+            if (!value.hasOwnProperty(field))
+                throw new sdk_core_1.BuildTransactionError(`Utxos required ${field}`);
+        });
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../src/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport BigNumber from 'bignumber.js';\nimport {\n  NotImplementedError,\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  TransactionType,\n  InvalidTransactionError,\n  ParseTransactionError,\n  BuildTransactionError,\n  NotSupported,\n  BaseTransaction,\n} from '@bitgo/sdk-core';\nimport { Transaction } from './transaction';\nimport { KeyPair } from './keyPair';\nimport { BN } from 'avalanche';\nimport { BaseTx } from 'avalanche/dist/apis/platformvm/basetx';\nimport { Credential } from 'avalanche/dist/common';\nimport utils from './utils';\nimport { DecodedUtxoObj } from './iface';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  private _transaction: Transaction;\n  public _signer: KeyPair[] = [];\n  protected recoverSigner = false;\n\n  /**\n   * When using recovery key must be set here\n   * TODO: STLX-17317 recovery key signing\n   * @param recoverSigner\n   */\n  public recoverMode(recoverSigner = true): this {\n    this.recoverSigner = recoverSigner;\n    return this;\n  }\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  /**\n   * commented out check until multisig signing is in effect\n   * TODO: STLX-17077\n   * @param value\n   */\n\n  threshold(value: number): this {\n    // this.validateThreshold(value);\n    this._transaction._threshold = value;\n    return this;\n  }\n\n  locktime(value: string | number): this {\n    this.validateLocktime(new BN(value));\n    this._transaction._locktime = new BN(value);\n    return this;\n  }\n\n  fromPubKey(senderPubKey: string | string[]): this {\n    const pubKeys = senderPubKey instanceof Array ? senderPubKey : [senderPubKey];\n    this._transaction._fromPubKeys = pubKeys.map(utils.parseAddress);\n    return this;\n  }\n\n  utxos(value: DecodedUtxoObj[]): this {\n    this.validateUtxos(value);\n    this._transaction._utxos = value;\n    return this;\n  }\n  /**\n   *\n   * @param value Optional Buffer for the memo\n   * @returns value Buffer for the memo\n   * set using Buffer.from(\"message\")\n   */\n  memo(value: string): this {\n    this._transaction._memo = utils.stringToBuffer(value);\n    return this;\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   */\n  initBuilder(tx?: BaseTx): this {\n    if (!tx) return this;\n    if (\n      tx.getNetworkID() !== this._transaction._networkID ||\n      !tx.getBlockchainID().equals(this._transaction._blockchainID)\n    ) {\n      throw new Error('Network or blockchain is not equals');\n    }\n    this._transaction._memo = tx.getMemo();\n    const out = tx.getOuts()[0];\n    if (!out.getAssetID().equals(this._transaction._assetId)) {\n      throw new Error('AssetID are not equals');\n    }\n    const secpOut = out.getOutput();\n    this._transaction._locktime = secpOut.getLocktime();\n    this._transaction._threshold = secpOut.getThreshold();\n    this._transaction._fromPubKeys = secpOut.getAddresses();\n    this._transaction.avaxPTransaction = tx;\n    return this;\n  }\n\n  credentials(credentials: Credential[]): this {\n    this.transaction.credentials = credentials;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    throw new NotSupported('from raw transaction is not supported. See TransactionBuilderFactory.from method');\n  }\n\n  get hasSigner(): boolean {\n    return this._signer !== undefined && this._signer.length > 0;\n  }\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    // TODO: STLX-17317: sign with recovery key\n    // if (this.hasSigner) {\n    //    this.recoverSigner = this._fromPubKeys[1].equals(utils.parseAddress(this._signer[0].getAddress()));\n    // }\n    this.transaction.avaxPTransaction = this.buildAvaxpTransaction();\n    if (this.hasSigner) {\n      if (!this.transaction.hasCredentials) {\n        this.transaction.credentials = utils.getCredentials(this.transaction.avaxPTransaction);\n      }\n      this._signer.forEach((keyPair) => this.transaction.sign(keyPair));\n    }\n    this.transaction.setTransactionType(this.transactionType);\n    return this.transaction;\n  }\n\n  /**\n   * Builds the avaxp transaction\n   * @return {Transaction} avaxp sdk transaction\n   */\n  protected abstract buildAvaxpTransaction(): BaseTx;\n\n  // region Getters and Setters\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  protected signImplementation({ key }: BaseKey): BaseTransaction {\n    this._signer.push(new KeyPair({ prv: key }));\n    return this.transaction;\n  }\n\n  protected abstract get transactionType(): TransactionType;\n\n  // endregion\n\n  // region Validators\n\n  /**\n   * Validates the threshold\n   * @param threshold\n   */\n  validateThreshold(threshold: number): void {\n    if (!threshold || threshold !== 2) {\n      throw new BuildTransactionError('Invalid transaction: threshold must be set to 2');\n    }\n  }\n\n  /**\n   * Validates locktime\n   * @param locktime\n   */\n  validateLocktime(locktime: BN): void {\n    if (!locktime || locktime.lt(new BN(0))) {\n      throw new BuildTransactionError('Invalid transaction: locktime must be 0 or higher');\n    }\n  }\n\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    throw new NotImplementedError('validateAddress not implemented');\n  }\n\n  /** @inheritdoc */\n  validateKey({ key }: BaseKey): void {\n    if (!new KeyPair({ prv: key })) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Raw transaction is empty');\n    }\n    try {\n      utils.cb58Decode(rawTransaction);\n    } catch (e) {\n      throw new ParseTransactionError('Raw transaction is not hex string');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    // throw new NotImplementedError('validateTransaction not implemented');\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be less than zero');\n    }\n  }\n\n  validateUtxos(values: DecodedUtxoObj[]): void {\n    if (values.length === 0) {\n      throw new BuildTransactionError(\"Utxos can't be empty array\");\n    }\n    values.forEach(this.validateUtxo);\n  }\n\n  validateUtxo(value: DecodedUtxoObj): void {\n    ['outputID', 'amount', 'txid', 'outputidx'].forEach((field) => {\n      if (!value.hasOwnProperty(field)) throw new BuildTransactionError(`Utxos required ${field}`);\n    });\n  }\n\n  // endregion\n}\n"]}

package/dist/src/transactionBuilderFactory.d.ts

@@ -0,0 +1,22 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseTransactionBuilderFactory } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { ValidatorTxBuilder } from './validatorTxBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    from(raw: string): TransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): TransferBuilder;
+    /**
+     * Initialize Validator builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {StakingTxBuilder} the builder initialized
+     */
+    getValidatorBuilder(): ValidatorTxBuilder;
+    getWalletInitializationBuilder(): TransactionBuilder;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../src/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,6BAA6B,EAAgB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,qBAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,SAAS,CAAC,aAAa,UAAS;gBACpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAcrC,kBAAkB;IAClB,kBAAkB,IAAI,eAAe;IAIrC;;;;;OAKG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC,8BAA8B,IAAI,kBAAkB;CAGrD"}

package/dist/src/transactionBuilderFactory.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transferBuilder_1 = require("./transferBuilder");
+const validatorTxBuilder_1 = require("./validatorTxBuilder");
+const utils_1 = __importDefault(require("./utils"));
+const constants_1 = require("avalanche/dist/apis/platformvm/constants");
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+    }
+    /** @inheritdoc */
+    from(raw) {
+        const tx = utils_1.default.from(raw);
+        const baseTx = tx.getUnsignedTx().getTransaction();
+        let transactionBuilder;
+        if (baseTx.getTypeID() === constants_1.PlatformVMConstants.ADDVALIDATORTX) {
+            transactionBuilder = this.getValidatorBuilder();
+        }
+        else {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        transactionBuilder.initBuilder(baseTx).credentials(tx.getCredentials());
+        return transactionBuilder;
+    }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        return new transferBuilder_1.TransferBuilder(this._coinConfig);
+    }
+    /**
+     * Initialize Validator builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {StakingTxBuilder} the builder initialized
+     */
+    getValidatorBuilder() {
+        return new validatorTxBuilder_1.ValidatorTxBuilder(this._coinConfig);
+    }
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotSupported('Wallet initialization is not needed');
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/transferBuilder.d.ts

@@ -0,0 +1,18 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseKey, TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { BaseTx } from 'avalanche/dist/apis/platformvm';
+export declare class TransferBuilder extends TransactionBuilder {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    protected buildAvaxpTransaction(): BaseTx;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+}
+//# sourceMappingURL=transferBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../src/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,EAAuB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAExD,qBAAa,eAAgB,SAAQ,kBAAkB;gBACzC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAI3D,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAIjE,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;CAGxD"}

package/dist/src/transferBuilder.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.WalletInitialization;
+    }
+    /** @inheritdoc */
+    buildAvaxpTransaction() {
+        throw new sdk_core_1.NotImplementedError('buildImplementation not implemented');
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        throw new sdk_core_1.NotImplementedError('buildImplementation not implemented');
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        throw new sdk_core_1.NotImplementedError('fromImplementation not implemented');
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        throw new sdk_core_1.NotImplementedError('signImplementation not implemented');
+    }
+}
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyYW5zZmVyQnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSw4Q0FBZ0Y7QUFDaEYsNkRBQTBEO0FBSTFELE1BQWEsZUFBZ0IsU0FBUSx1Q0FBa0I7SUFDckQsWUFBWSxXQUFpQztRQUMzQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELElBQWMsZUFBZTtRQUMzQixPQUFPLDBCQUFlLENBQUMsb0JBQW9CLENBQUM7SUFDOUMsQ0FBQztJQUVELGtCQUFrQjtJQUNSLHFCQUFxQjtRQUM3QixNQUFNLElBQUksOEJBQW1CLENBQUMscUNBQXFDLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQsa0JBQWtCO0lBQ1IsS0FBSyxDQUFDLG1CQUFtQjtRQUNqQyxNQUFNLElBQUksOEJBQW1CLENBQUMscUNBQXFDLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQsa0JBQWtCO0lBQ1Isa0JBQWtCLENBQUMsY0FBc0I7UUFDakQsTUFBTSxJQUFJLDhCQUFtQixDQUFDLG9DQUFvQyxDQUFDLENBQUM7SUFDdEUsQ0FBQztJQUVELGtCQUFrQjtJQUNSLGtCQUFrQixDQUFDLEdBQVk7UUFDdkMsTUFBTSxJQUFJLDhCQUFtQixDQUFDLG9DQUFvQyxDQUFDLENBQUM7SUFDdEUsQ0FBQztDQUNGO0FBNUJELDBDQTRCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28vc3RhdGljcyc7XG5pbXBvcnQgeyBCYXNlS2V5LCBOb3RJbXBsZW1lbnRlZEVycm9yLCBUcmFuc2FjdGlvblR5cGUgfSBmcm9tICdAYml0Z28vc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi90cmFuc2FjdGlvbkJ1aWxkZXInO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb24gfSBmcm9tICcuL3RyYW5zYWN0aW9uJztcbmltcG9ydCB7IEJhc2VUeCB9IGZyb20gJ2F2YWxhbmNoZS9kaXN0L2FwaXMvcGxhdGZvcm12bSc7XG5cbmV4cG9ydCBjbGFzcyBUcmFuc2ZlckJ1aWxkZXIgZXh0ZW5kcyBUcmFuc2FjdGlvbkJ1aWxkZXIge1xuICBjb25zdHJ1Y3RvcihfY29pbkNvbmZpZzogUmVhZG9ubHk8Q29pbkNvbmZpZz4pIHtcbiAgICBzdXBlcihfY29pbkNvbmZpZyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgZ2V0IHRyYW5zYWN0aW9uVHlwZSgpOiBUcmFuc2FjdGlvblR5cGUge1xuICAgIHJldHVybiBUcmFuc2FjdGlvblR5cGUuV2FsbGV0SW5pdGlhbGl6YXRpb247XG4gIH1cblxuICAvKiogQGluaGVyaXRkb2MgKi9cbiAgcHJvdGVjdGVkIGJ1aWxkQXZheHBUcmFuc2FjdGlvbigpOiBCYXNlVHgge1xuICAgIHRocm93IG5ldyBOb3RJbXBsZW1lbnRlZEVycm9yKCdidWlsZEltcGxlbWVudGF0aW9uIG5vdCBpbXBsZW1lbnRlZCcpO1xuICB9XG5cbiAgLyoqIEBpbmhlcml0ZG9jICovXG4gIHByb3RlY3RlZCBhc3luYyBidWlsZEltcGxlbWVudGF0aW9uKCk6IFByb21pc2U8VHJhbnNhY3Rpb24+IHtcbiAgICB0aHJvdyBuZXcgTm90SW1wbGVtZW50ZWRFcnJvcignYnVpbGRJbXBsZW1lbnRhdGlvbiBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBwcm90ZWN0ZWQgZnJvbUltcGxlbWVudGF0aW9uKHJhd1RyYW5zYWN0aW9uOiBzdHJpbmcpOiBUcmFuc2FjdGlvbiB7XG4gICAgdGhyb3cgbmV3IE5vdEltcGxlbWVudGVkRXJyb3IoJ2Zyb21JbXBsZW1lbnRhdGlvbiBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBwcm90ZWN0ZWQgc2lnbkltcGxlbWVudGF0aW9uKGtleTogQmFzZUtleSk6IFRyYW5zYWN0aW9uIHtcbiAgICB0aHJvdyBuZXcgTm90SW1wbGVtZW50ZWRFcnJvcignc2lnbkltcGxlbWVudGF0aW9uIG5vdCBpbXBsZW1lbnRlZCcpO1xuICB9XG59XG4iXX0=