@bitgo-beta/sdk-coin-avaxp 2.0.0

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

@@ -0,0 +1,122 @@
+/// <reference types="bn.js" />
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import BigNumber from 'bignumber.js';
+import { BaseAddress, BaseKey, BaseTransactionBuilder, TransactionType, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { KeyPair } from './keyPair';
+import { BN, Buffer as BufferAvax } from 'avalanche';
+import { DecodedUtxoObj, Tx } from './iface';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    private _transaction;
+    _signer: KeyPair[];
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx: Tx): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Builds the avaxp transaction. transaction field is changed.
+     */
+    protected abstract buildAvaxpTransaction(): void;
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param {boolean} true if it's recovery signer, default true.
+     */
+    recoverMode(recoverSigner?: boolean): this;
+    /**
+     * Threshold is an int that names the number of unique signatures required to spend the output.
+     * Must be less than or equal to the length of Addresses.
+     * @param {number}
+     */
+    threshold(value: number): this;
+    /**
+     * Locktime is a long that contains the unix timestamp that this output can be spent after.
+     * The unix timestamp is specific to the second.
+     * @param value
+     */
+    locktime(value: string | number): this;
+    /**
+     * fromPubKey is a list of unique addresses that correspond to the private keys that can be used to spend this output.
+     * @param {string | stirng[]} senderPubKey
+     */
+    fromPubKey(senderPubKey: string | string[]): this;
+    /**
+     * List of UTXO required as inputs.
+     * A UTXO is a standalone representation of a transaction output.
+     *
+     * @param {DecodedUtxoObj[]} list of UTXOS
+     */
+    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;
+    /**
+     * Getter for know if build should sign
+     */
+    get hasSigner(): boolean;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    protected set transaction(transaction: Transaction);
+    /** @inheritdoc */
+    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;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     * It overrides abstract method from BaseTransactionBuilder
+     *
+     * @param rawTransaction Transaction in any format
+     */
+    validateRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    validateTransaction(transaction?: Transaction): void;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    /**
+     * Check the list of UTXOS is empty and check each UTXO.
+     * @param values
+     */
+    validateUtxos(values: DecodedUtxoObj[]): void;
+    /**
+     * Check the UTXO has expected fields.
+     * @param UTXO
+     */
+    validateUtxo(value: DecodedUtxoObj): void;
+    /**
+     * Check the amount is positive.
+     * @param amount
+     */
+    validateAmount(amount: BN): void;
+    /**
+     * Check the buffer has 32 byte long.
+     * @param chainID
+     */
+    validateChainId(chainID: BufferAvax): void;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EACL,WAAW,EACX,OAAO,EACP,sBAAsB,EACtB,eAAe,EAEf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,EAAE,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAG7C,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,OAAO,CAAC,YAAY,CAAc;IAC3B,OAAO,EAAE,OAAO,EAAE,CAAM;IAC/B,SAAS,CAAC,aAAa,UAAS;gBAEpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAgBzB,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAOjE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAS3D;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,qBAAqB,IAAI,IAAI;IAGhD;;;;OAIG;IACI,WAAW,CAAC,aAAa,UAAO,GAAG,IAAI;IAK9C;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM9B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAMjD;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAKpC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;IAED,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,eAAe;IAK/D,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAK1D;;;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;IAMnE,kBAAkB;IAClB,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,IAAI;IAMnC;;;;;OAKG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAIpD,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAIpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI;IAO7C;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAMzC;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI;IAMhC;;;OAGG;IACH,eAAe,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;CAO3C"}

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,224 @@
+"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-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const keyPair_1 = require("./keyPair");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signer = [];
+        this.recoverSigner = false;
+        this._transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx) {
+        const baseTx = tx.getUnsignedTx().getTransaction();
+        if (baseTx.getNetworkID() !== this._transaction._networkID ||
+            !baseTx.getBlockchainID().equals(this._transaction._blockchainID)) {
+            throw new Error('Network or blockchain is not equals');
+        }
+        // EVMBaseTx has not memo.
+        if ('getMemo' in baseTx) {
+            this._transaction._memo = baseTx.getMemo();
+        }
+        this._transaction.setTransaction(tx);
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new platformvm_1.Tx();
+        tx.fromBuffer(avalanche_1.Buffer.from(rawTransaction, 'hex'));
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this.buildAvaxpTransaction();
+        this.transaction.setTransactionType(this.transactionType);
+        if (this.hasSigner) {
+            this._signer.forEach((keyPair) => this.transaction.sign(keyPair));
+        }
+        return this.transaction;
+    }
+    // region Getters and Setters
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param {boolean} true if it's recovery signer, default true.
+     */
+    recoverMode(recoverSigner = true) {
+        this.recoverSigner = recoverSigner;
+        return this;
+    }
+    /**
+     * Threshold is an int that names the number of unique signatures required to spend the output.
+     * Must be less than or equal to the length of Addresses.
+     * @param {number}
+     */
+    threshold(value) {
+        this.validateThreshold(value);
+        this._transaction._threshold = value;
+        return this;
+    }
+    /**
+     * Locktime is a long that contains the unix timestamp that this output can be spent after.
+     * The unix timestamp is specific to the second.
+     * @param value
+     */
+    locktime(value) {
+        this.validateLocktime(new avalanche_1.BN(value));
+        this._transaction._locktime = new avalanche_1.BN(value);
+        return this;
+    }
+    /**
+     * fromPubKey is a list of unique addresses that correspond to the private keys that can be used to spend this output.
+     * @param {string | stirng[]} senderPubKey
+     */
+    fromPubKey(senderPubKey) {
+        const pubKeys = senderPubKey instanceof Array ? senderPubKey : [senderPubKey];
+        this._transaction._fromAddresses = pubKeys.map(utils_1.default.parseAddress);
+        return this;
+    }
+    /**
+     * List of UTXO required as inputs.
+     * A UTXO is a standalone representation of a transaction output.
+     *
+     * @param {DecodedUtxoObj[]} list of UTXOS
+     */
+    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;
+    }
+    /**
+     * Getter for know if build should sign
+     */
+    get hasSigner() {
+        return this._signer !== undefined && this._signer.length > 0;
+    }
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /** @inheritdoc */
+    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) {
+        if (!utils_1.default.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address');
+        }
+    }
+    /** @inheritdoc */
+    validateKey({ key }) {
+        if (!new keyPair_1.KeyPair({ prv: key })) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     * It overrides abstract method from BaseTransactionBuilder
+     *
+     * @param rawTransaction Transaction in any format
+     */
+    validateRawTransaction(rawTransaction) {
+        utils_1.default.validateRawTransaction(rawTransaction);
+    }
+    /** @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');
+        }
+    }
+    /**
+     * Check the list of UTXOS is empty and check each UTXO.
+     * @param values
+     */
+    validateUtxos(values) {
+        if (values.length === 0) {
+            throw new sdk_core_1.BuildTransactionError("Utxos can't be empty array");
+        }
+        values.forEach(this.validateUtxo);
+    }
+    /**
+     * Check the UTXO has expected fields.
+     * @param UTXO
+     */
+    validateUtxo(value) {
+        ['outputID', 'amount', 'txid', 'outputidx'].forEach((field) => {
+            if (!value.hasOwnProperty(field))
+                throw new sdk_core_1.BuildTransactionError(`Utxos required ${field}`);
+        });
+    }
+    /**
+     * Check the amount is positive.
+     * @param amount
+     */
+    validateAmount(amount) {
+        if (amount.lten(0)) {
+            throw new sdk_core_1.BuildTransactionError('Amount must be greater than 0');
+        }
+    }
+    /**
+     * Check the buffer has 32 byte long.
+     * @param chainID
+     */
+    validateChainId(chainID) {
+        if (chainID.length != 32) {
+            throw new sdk_core_1.BuildTransactionError('Chain id are 32 byte size');
+        }
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport BigNumber from 'bignumber.js';\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  TransactionType,\n  BuildTransactionError,\n  BaseTransaction,\n} from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport { KeyPair } from './keyPair';\nimport { BN, Buffer as BufferAvax } from 'avalanche';\nimport utils from './utils';\nimport { DecodedUtxoObj, Tx } from './iface';\nimport { Tx as PVMTx } from 'avalanche/dist/apis/platformvm';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  private _transaction: Transaction;\n  public _signer: KeyPair[] = [];\n  protected recoverSigner = false;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   * @returns itself\n   */\n  initBuilder(tx: Tx): this {\n    const baseTx = tx.getUnsignedTx().getTransaction();\n    if (\n      baseTx.getNetworkID() !== this._transaction._networkID ||\n      !baseTx.getBlockchainID().equals(this._transaction._blockchainID)\n    ) {\n      throw new Error('Network or blockchain is not equals');\n    }\n    // EVMBaseTx has not memo.\n    if ('getMemo' in baseTx) {\n      this._transaction._memo = baseTx.getMemo();\n    }\n    this._transaction.setTransaction(tx);\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = new PVMTx();\n    tx.fromBuffer(BufferAvax.from(rawTransaction, 'hex'));\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this.buildAvaxpTransaction();\n    this.transaction.setTransactionType(this.transactionType);\n    if (this.hasSigner) {\n      this._signer.forEach((keyPair) => this.transaction.sign(keyPair));\n    }\n    return this.transaction;\n  }\n\n  /**\n   * Builds the avaxp transaction. transaction field is changed.\n   */\n  protected abstract buildAvaxpTransaction(): void;\n\n  // region Getters and Setters\n  /**\n   * When using recovery key must be set here\n   * TODO: STLX-17317 recovery key signing\n   * @param {boolean} true if it's recovery signer, default true.\n   */\n  public recoverMode(recoverSigner = true): this {\n    this.recoverSigner = recoverSigner;\n    return this;\n  }\n\n  /**\n   * Threshold is an int that names the number of unique signatures required to spend the output.\n   * Must be less than or equal to the length of Addresses.\n   * @param {number}\n   */\n  threshold(value: number): this {\n    this.validateThreshold(value);\n    this._transaction._threshold = value;\n    return this;\n  }\n\n  /**\n   * Locktime is a long that contains the unix timestamp that this output can be spent after.\n   * The unix timestamp is specific to the second.\n   * @param value\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  /**\n   * fromPubKey is a list of unique addresses that correspond to the private keys that can be used to spend this output.\n   * @param {string | stirng[]} senderPubKey\n   */\n  fromPubKey(senderPubKey: string | string[]): this {\n    const pubKeys = senderPubKey instanceof Array ? senderPubKey : [senderPubKey];\n    this._transaction._fromAddresses = pubKeys.map(utils.parseAddress);\n    return this;\n  }\n\n  /**\n   * List of UTXO required as inputs.\n   * A UTXO is a standalone representation of a transaction output.\n   *\n   * @param {DecodedUtxoObj[]} list of UTXOS\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   * Getter for know if build should sign\n   */\n  get hasSigner(): boolean {\n    return this._signer !== undefined && this._signer.length > 0;\n  }\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /** @inheritdoc */\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  // 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    if (!utils.isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address');\n    }\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  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   * It overrides abstract method from BaseTransactionBuilder\n   *\n   * @param rawTransaction Transaction in any format\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    utils.validateRawTransaction(rawTransaction);\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  /**\n   * Check the list of UTXOS is empty and check each UTXO.\n   * @param values\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  /**\n   * Check the UTXO has expected fields.\n   * @param UTXO\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  /**\n   * Check the amount is positive.\n   * @param amount\n   */\n  validateAmount(amount: BN): void {\n    if (amount.lten(0)) {\n      throw new BuildTransactionError('Amount must be greater than 0');\n    }\n  }\n\n  /**\n   * Check the buffer has 32 byte long.\n   * @param chainID\n   */\n  validateChainId(chainID: BufferAvax): void {\n    if (chainID.length != 32) {\n      throw new BuildTransactionError('Chain id are 32 byte size');\n    }\n  }\n\n  // endregion\n}\n"]}

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

@@ -0,0 +1,42 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { ValidatorTxBuilder } from './validatorTxBuilder';
+import { ExportTxBuilder } from './exportTxBuilder';
+import { ImportTxBuilder } from './importTxBuilder';
+import { ImportInCTxBuilder } from './importInCTxBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    from(raw: string): TransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): TransactionBuilder;
+    /**
+     * Initialize Validator builder
+     *
+     * @returns {ValidatorTxBuilder} the builder initialized
+     */
+    getValidatorBuilder(): ValidatorTxBuilder;
+    /**
+     * Export Cross chain transfer
+     *
+     * @returns {ExportTxBuilder} the builder initialized
+     */
+    getExportBuilder(): ExportTxBuilder;
+    /**
+     * Import Cross chain transfer
+     *
+     * @returns {ImportTxBuilder} the builder initialized
+     */
+    getImportBuilder(): ImportTxBuilder;
+    /**
+     * Import in C chain Cross chain transfer
+     *
+     * @returns {ImportInCTxBuilder} the builder initialized
+     */
+    getImportInCBuilder(): ImportInCTxBuilder;
+    /** @inheritdoc */
+    getWalletInitializationBuilder(): TransactionBuilder;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAE,6BAA6B,EAAgB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAK1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,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;IA2CrC,kBAAkB;IAClB,kBAAkB,IAAI,kBAAkB;IAIxC;;;;OAIG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;;;OAIG;IACH,gBAAgB,IAAI,eAAe;IAInC;;;;OAIG;IACH,gBAAgB,IAAI,eAAe;IAInC;;;;OAIG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC,kBAAkB;IAClB,8BAA8B,IAAI,kBAAkB;CAGrD"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -0,0 +1,107 @@
+"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-beta/sdk-core");
+const validatorTxBuilder_1 = require("./validatorTxBuilder");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const evm_1 = require("avalanche/dist/apis/evm");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+const exportTxBuilder_1 = require("./exportTxBuilder");
+const importTxBuilder_1 = require("./importTxBuilder");
+const importInCTxBuilder_1 = require("./importInCTxBuilder");
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+    }
+    /** @inheritdoc */
+    from(raw) {
+        utils_1.default.validateRawTransaction(raw);
+        let txSource = 'PVM';
+        let tx;
+        let transactionBuilder = undefined;
+        try {
+            tx = new platformvm_1.Tx();
+            // could throw an error if a txType doesn't match.
+            tx.fromBuffer(avalanche_1.Buffer.from(raw, 'hex'));
+            if (!utils_1.default.isTransactionOf(tx, this._coinConfig.network.blockchainID)) {
+                throw new Error('It is not a transaction of this network');
+            }
+        }
+        catch {
+            txSource = 'EVM';
+            tx = new evm_1.Tx();
+            tx.fromBuffer(avalanche_1.Buffer.from(raw, 'hex'));
+            if (!utils_1.default.isTransactionOf(tx, this._coinConfig.network.cChainBlockchainID)) {
+                throw new Error('It is not a transaction of this network or C chain');
+            }
+        }
+        if (txSource === 'PVM') {
+            if (validatorTxBuilder_1.ValidatorTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getValidatorBuilder();
+            }
+            else if (exportTxBuilder_1.ExportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getExportBuilder();
+            }
+            else if (importTxBuilder_1.ImportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getImportBuilder();
+            }
+        }
+        else if (txSource === 'EVM') {
+            if (importInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getImportInCBuilder();
+            }
+        }
+        if (transactionBuilder === undefined) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        transactionBuilder.initBuilder(tx);
+        return transactionBuilder;
+    }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        throw new sdk_core_1.NotSupported('Transfer is not supported in P Chain');
+    }
+    /**
+     * Initialize Validator builder
+     *
+     * @returns {ValidatorTxBuilder} the builder initialized
+     */
+    getValidatorBuilder() {
+        return new validatorTxBuilder_1.ValidatorTxBuilder(this._coinConfig);
+    }
+    /**
+     * Export Cross chain transfer
+     *
+     * @returns {ExportTxBuilder} the builder initialized
+     */
+    getExportBuilder() {
+        return new exportTxBuilder_1.ExportTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import Cross chain transfer
+     *
+     * @returns {ImportTxBuilder} the builder initialized
+     */
+    getImportBuilder() {
+        return new importTxBuilder_1.ImportTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import in C chain Cross chain transfer
+     *
+     * @returns {ImportInCTxBuilder} the builder initialized
+     */
+    getImportInCBuilder() {
+        return new importInCTxBuilder_1.ImportInCTxBuilder(this._coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotSupported('Wallet initialization is not needed');
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { AvalancheNetwork, BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BaseTransactionBuilderFactory, NotSupported } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { ValidatorTxBuilder } from './validatorTxBuilder';\nimport { Tx } from 'avalanche/dist/apis/platformvm';\nimport { Tx as EVMTx } from 'avalanche/dist/apis/evm';\nimport { Buffer as BufferAvax } from 'avalanche';\nimport utils from './utils';\nimport { ExportTxBuilder } from './exportTxBuilder';\nimport { ImportTxBuilder } from './importTxBuilder';\nimport { ImportInCTxBuilder } from './importInCTxBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  protected recoverSigner = false;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  from(raw: string): TransactionBuilder {\n    utils.validateRawTransaction(raw);\n    let txSource: 'EVM' | 'PVM' = 'PVM';\n    let tx: Tx | EVMTx;\n    let transactionBuilder: TransactionBuilder | undefined = undefined;\n\n    try {\n      tx = new Tx();\n      // could throw an error if a txType doesn't match.\n      tx.fromBuffer(BufferAvax.from(raw, 'hex'));\n\n      if (!utils.isTransactionOf(tx, (this._coinConfig.network as AvalancheNetwork).blockchainID)) {\n        throw new Error('It is not a transaction of this network');\n      }\n    } catch {\n      txSource = 'EVM';\n      tx = new EVMTx();\n      tx.fromBuffer(BufferAvax.from(raw, 'hex'));\n\n      if (!utils.isTransactionOf(tx, (this._coinConfig.network as AvalancheNetwork).cChainBlockchainID)) {\n        throw new Error('It is not a transaction of this network or C chain');\n      }\n    }\n    if (txSource === 'PVM') {\n      if (ValidatorTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getValidatorBuilder();\n      } else if (ExportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getExportBuilder();\n      } else if (ImportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getImportBuilder();\n      }\n    } else if (txSource === 'EVM') {\n      if (ImportInCTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getImportInCBuilder();\n      }\n    }\n    if (transactionBuilder === undefined) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n    transactionBuilder.initBuilder(tx);\n    return transactionBuilder;\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(): TransactionBuilder {\n    throw new NotSupported('Transfer is not supported in P Chain');\n  }\n\n  /**\n   * Initialize Validator builder\n   *\n   * @returns {ValidatorTxBuilder} the builder initialized\n   */\n  getValidatorBuilder(): ValidatorTxBuilder {\n    return new ValidatorTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Export Cross chain transfer\n   *\n   * @returns {ExportTxBuilder} the builder initialized\n   */\n  getExportBuilder(): ExportTxBuilder {\n    return new ExportTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import Cross chain transfer\n   *\n   * @returns {ImportTxBuilder} the builder initialized\n   */\n  getImportBuilder(): ImportTxBuilder {\n    return new ImportTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import in C chain Cross chain transfer\n   *\n   * @returns {ImportInCTxBuilder} the builder initialized\n   */\n  getImportInCBuilder(): ImportInCTxBuilder {\n    return new ImportInCTxBuilder(this._coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): TransactionBuilder {\n    throw new NotSupported('Wallet initialization is not needed');\n  }\n}\n"]}

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

@@ -0,0 +1,18 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseKey, TransactionType } from '@bitgo-beta/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/lib/transferBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/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/lib/transferBuilder.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/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,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