@bitgo-beta/sdk-coin-avaxp 0.0.0-semantic-release-managed

package/dist/src/lib/transaction.js

@@ -0,0 +1,254 @@
+"use strict";
+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 avalanchejs_1 = require("@bitgo-forks/avalanchejs");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const avalanche_1 = require("avalanche");
+const iface_1 = require("./iface");
+const utils_1 = __importDefault(require("./utils"));
+/**
+ * Checks if a signature is empty
+ * @param signature
+ * @returns {boolean}
+ */
+function isEmptySignature(signature) {
+    return !!signature && utils_1.default.removeHexPrefix(signature).startsWith(''.padStart(90, '0'));
+}
+function generateSelectorSignature(signatures) {
+    if (signatures.length > 1 && signatures.every((sig) => isEmptySignature(sig))) {
+        // Look for address.
+        return function (sig, address) {
+            try {
+                if (!isEmptySignature(sig)) {
+                    return false;
+                }
+                if (sig.startsWith('0x'))
+                    sig = sig.substring(2);
+                const pub = sig.substring(90);
+                return pub === address;
+            }
+            catch (e) {
+                return false;
+            }
+        };
+    }
+    else {
+        // Look for empty string
+        return function (sig, address) {
+            return isEmptySignature(sig);
+        };
+    }
+}
+// end region utils for sign
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._threshold = 2;
+        this._locktime = BigInt(0);
+        this._fromAddresses = [];
+        this._rewardAddresses = [];
+        this._utxos = [];
+        this._fee = {};
+        this._network = coinConfig.network;
+        this._assetId = this._network.avaxAssetID;
+        this._blockchainID = this._network.blockchainID;
+        this._networkID = this._network.networkID;
+    }
+    get avaxPTransaction() {
+        return this._avaxTransaction.getTx().baseTx;
+    }
+    get signature() {
+        if (this.credentials.length === 0) {
+            return [];
+        }
+        return this.credentials[0].getSignatures().filter((s) => !isEmptySignature(s));
+    }
+    get credentials() {
+        return this._avaxTransaction?.credentials;
+    }
+    get hasCredentials() {
+        return this.credentials !== undefined && this.credentials.length > 0;
+    }
+    /** @inheritdoc */
+    canSign({ key }) {
+        // TODO(BG-56700):  Improve canSign by check in addresses in empty credentials match signer
+        return true;
+    }
+    /**
+     * Sign an avaxp transaction and update the transaction hex
+     * @param {KeyPair} keyPair
+     */
+    async sign(keyPair) {
+        const prv = keyPair.getPrivateKey();
+        const addressHex = keyPair.getAddressBuffer().toString('hex');
+        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 unsignedTx = this._avaxTransaction;
+        const unsignedBytes = unsignedTx.toBytes();
+        const publicKey = avalanchejs_1.secp256k1.getPublicKey(prv);
+        if (unsignedTx.hasPubkey(publicKey)) {
+            const signature = await avalanchejs_1.secp256k1.sign(unsignedBytes, prv);
+            let checkSign = undefined;
+            unsignedTx.credentials.forEach((c, index) => {
+                if (checkSign === undefined) {
+                    checkSign = generateSelectorSignature(c.getSignatures());
+                }
+                let find = false;
+                c.getSignatures().forEach((sig, index) => {
+                    if (checkSign && checkSign(sig, addressHex)) {
+                        c.setSignature(index, signature);
+                        find = true;
+                    }
+                });
+                if (!find) {
+                    throw new sdk_core_1.SigningError(`Private key cannot sign the transaction, address hex ${addressHex}, public key: ${publicKey}`);
+                }
+            });
+        }
+    }
+    toHexString(byteArray) {
+        return avalanchejs_1.utils.bufferToHex(byteArray);
+    }
+    /** @inheritdoc */
+    /**
+     * should be of signedTx doing this with baseTx
+     */
+    toBroadcastFormat() {
+        if (!this.avaxPTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        return this.toHexString(avalanchejs_1.utils.addChecksum(this._avaxTransaction.getSignedTx().toBytes()));
+    }
+    // types - stakingTransaction, import, export
+    toJson() {
+        if (!this.avaxPTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        return {
+            id: this.id,
+            inputs: this.inputs,
+            fromAddresses: this.fromAddresses,
+            threshold: this._threshold,
+            locktime: this._locktime.toString(),
+            type: this.type,
+            signatures: this.signature,
+            outputs: this.outputs,
+            changeOutputs: this.changeOutputs,
+        };
+    }
+    setTransaction(tx) {
+        this._avaxTransaction = tx;
+    }
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType) {
+        if (![sdk_core_1.TransactionType.AddPermissionlessValidator].includes(transactionType)) {
+            throw new Error(`Transaction type ${transactionType} is not supported`);
+        }
+        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() {
+        return utils_1.default.sha256(this._avaxTransaction.toBytes());
+    }
+    get id() {
+        const bufferArray = utils_1.default.sha256(this._avaxTransaction.toBytes());
+        return utils_1.default.cb58Encode(avalanche_1.Buffer.from(bufferArray));
+    }
+    get fromAddresses() {
+        return this._fromAddresses.map((a) => avalanchejs_1.utils.format(this._network.alias, this._network.hrp, a));
+    }
+    get rewardAddresses() {
+        return this._rewardAddresses.map((a) => avalanchejs_1.utils.format(this._network.alias, this._network.hrp, a));
+    }
+    /**
+     * Get the list of outputs. Amounts are expressed in absolute value.
+     */
+    get outputs() {
+        switch (this.type) {
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+                return [
+                    {
+                        address: this._avaxTransaction.getTx().subnetValidator.validator.nodeId.toString(),
+                        value: this._avaxTransaction.getTx().subnetValidator.validator.weight.toJSON(),
+                    },
+                ];
+            default:
+                return [];
+        }
+    }
+    get fee() {
+        return { fee: '0', ...this._fee };
+    }
+    get changeOutputs() {
+        return this._avaxTransaction.getTx().baseTx.outputs.map(utils_1.default.mapOutputToEntry(this._network));
+    }
+    get inputs() {
+        let inputs;
+        switch (this.type) {
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+            default:
+                inputs = this._avaxTransaction.getTx().baseTx
+                    .inputs;
+                break;
+        }
+        return inputs.map((input) => {
+            return {
+                id: input.utxoID.txID.toString() + iface_1.INPUT_SEPARATOR + input.utxoID.outputIdx.value(),
+                address: this.fromAddresses.sort().join(iface_1.ADDRESS_SEPARATOR),
+                value: input.amount().toString(),
+            };
+        });
+    }
+    /**
+     * Avax wrapper to create signature and return it for credentials
+     * @param prv
+     * @return hexstring
+     */
+    createSignature(prv) {
+        const signval = utils_1.default.createSignatureAvaxBuffer(this._network, avalanche_1.Buffer.from(this.signablePayload), avalanche_1.Buffer.from(prv));
+        return signval.toString('hex');
+    }
+    /** @inheritdoc */
+    explainTransaction() {
+        const txJson = this.toJson();
+        const displayOrder = ['id', 'inputs', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'];
+        const outputAmount = txJson.outputs.reduce((p, n) => p.add(new avalanche_1.BN(n.value)), new avalanche_1.BN(0)).toString();
+        const changeAmount = txJson.changeOutputs.reduce((p, n) => p.add(new avalanche_1.BN(n.value)), new avalanche_1.BN(0)).toString();
+        let rewardAddresses;
+        if ([sdk_core_1.TransactionType.AddPermissionlessValidator].includes(txJson.type)) {
+            rewardAddresses = this.rewardAddresses;
+            displayOrder.splice(6, 0, 'rewardAddresses');
+        }
+        return {
+            displayOrder,
+            id: txJson.id,
+            inputs: txJson.inputs,
+            outputs: txJson.outputs.map((o) => ({ address: o.address, amount: o.value })),
+            outputAmount,
+            changeOutputs: txJson.changeOutputs.map((o) => ({ address: o.address, amount: o.value })),
+            changeAmount,
+            rewardAddresses,
+            fee: this.fee,
+            type: txJson.type,
+        };
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { avaxSerial, utils as avaxUtils, Credential, pvmSerial, secp256k1, UnsignedTx } from '@bitgo-forks/avalanchejs';\nimport {\n  BaseKey,\n  BaseTransaction,\n  Entry,\n  InvalidTransactionError,\n  SigningError,\n  TransactionFee,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport { AvalancheNetwork, BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BN, Buffer as BufferAvax } from 'avalanche';\nimport { Buffer } from 'buffer';\nimport { ADDRESS_SEPARATOR, DecodedUtxoObj, INPUT_SEPARATOR, TransactionExplanation, Tx, TxData } from './iface';\nimport { KeyPair } from './keyPair';\nimport utils from './utils';\n\n/**\n * Checks if a signature is empty\n * @param signature\n * @returns {boolean}\n */\nfunction isEmptySignature(signature: string): boolean {\n  return !!signature && utils.removeHexPrefix(signature).startsWith(''.padStart(90, '0'));\n}\n\ninterface CheckSignature {\n  (sigature: string, addressHex: string): boolean;\n}\n\nfunction generateSelectorSignature(signatures: string[]): CheckSignature {\n  if (signatures.length > 1 && signatures.every((sig) => isEmptySignature(sig))) {\n    // Look for address.\n    return function (sig, address): boolean {\n      try {\n        if (!isEmptySignature(sig)) {\n          return false;\n        }\n        if (sig.startsWith('0x')) sig = sig.substring(2);\n        const pub = sig.substring(90);\n        return pub === address;\n      } catch (e) {\n        return false;\n      }\n    };\n  } else {\n    // Look for empty string\n    return function (sig, address): boolean {\n      return isEmptySignature(sig);\n    };\n  }\n}\n// end region utils for sign\n\nexport class Transaction extends BaseTransaction {\n  protected _avaxTransaction: Tx;\n  public _type: TransactionType;\n  public _network: AvalancheNetwork;\n  public _networkID: number;\n  public _assetId: string;\n  public _blockchainID: string;\n  public _nodeID: string;\n  public _startTime: bigint;\n  public _endTime: bigint;\n  public _stakeAmount: bigint;\n  public _threshold = 2;\n  public _locktime = BigInt(0);\n  public _fromAddresses: Uint8Array[] = [];\n  public _rewardAddresses: BufferAvax[] = [];\n  public _utxos: DecodedUtxoObj[] = [];\n  public _to: BufferAvax[];\n  public _fee: Partial<TransactionFee> = {};\n  public _blsPublicKey: string;\n  public _blsSignature: string;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._network = coinConfig.network as AvalancheNetwork;\n    this._assetId = this._network.avaxAssetID;\n    this._blockchainID = this._network.blockchainID;\n    this._networkID = this._network.networkID;\n  }\n\n  get avaxPTransaction(): avaxSerial.BaseTx {\n    return ((this._avaxTransaction as UnsignedTx).getTx() as pvmSerial.AddPermissionlessValidatorTx).baseTx;\n  }\n\n  get signature(): string[] {\n    if (this.credentials.length === 0) {\n      return [];\n    }\n    return this.credentials[0].getSignatures().filter((s) => !isEmptySignature(s));\n  }\n\n  get credentials(): Credential[] {\n    return (this._avaxTransaction as UnsignedTx)?.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    // TODO(BG-56700):  Improve canSign by check in addresses in empty credentials match signer\n    return true;\n  }\n\n  /**\n   * Sign an avaxp transaction and update the transaction hex\n   * @param {KeyPair} keyPair\n   */\n  async sign(keyPair: KeyPair): Promise<void> {\n    const prv = keyPair.getPrivateKey() as Uint8Array;\n    const addressHex = keyPair.getAddressBuffer().toString('hex');\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 unsignedTx = this._avaxTransaction as UnsignedTx;\n    const unsignedBytes = unsignedTx.toBytes();\n\n    const publicKey = secp256k1.getPublicKey(prv);\n    if (unsignedTx.hasPubkey(publicKey)) {\n      const signature = await secp256k1.sign(unsignedBytes, prv);\n      let checkSign: CheckSignature | undefined = undefined;\n      unsignedTx.credentials.forEach((c, index) => {\n        if (checkSign === undefined) {\n          checkSign = generateSelectorSignature(c.getSignatures());\n        }\n        let find = false;\n        c.getSignatures().forEach((sig, index) => {\n          if (checkSign && checkSign(sig, addressHex)) {\n            c.setSignature(index, signature);\n            find = true;\n          }\n        });\n        if (!find) {\n          throw new SigningError(\n            `Private key cannot sign the transaction, address hex ${addressHex}, public key: ${publicKey}`\n          );\n        }\n      });\n    }\n  }\n\n  toHexString(byteArray: Uint8Array): string {\n    return avaxUtils.bufferToHex(byteArray);\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    return this.toHexString(avaxUtils.addChecksum((this._avaxTransaction as UnsignedTx).getSignedTx().toBytes()));\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      id: this.id,\n      inputs: this.inputs,\n      fromAddresses: this.fromAddresses,\n      threshold: this._threshold,\n      locktime: this._locktime.toString(),\n      type: this.type,\n      signatures: this.signature,\n      outputs: this.outputs,\n      changeOutputs: this.changeOutputs,\n    };\n  }\n\n  setTransaction(tx: Tx): void {\n    this._avaxTransaction = 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    if (![TransactionType.AddPermissionlessValidator].includes(transactionType)) {\n      throw new Error(`Transaction type ${transactionType} is not supported`);\n    }\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    return utils.sha256((this._avaxTransaction as UnsignedTx).toBytes());\n  }\n\n  get id(): string {\n    const bufferArray = utils.sha256((this._avaxTransaction as UnsignedTx).toBytes());\n    return utils.cb58Encode(BufferAvax.from(bufferArray));\n  }\n\n  get fromAddresses(): string[] {\n    return this._fromAddresses.map((a) => avaxUtils.format(this._network.alias, this._network.hrp, a));\n  }\n\n  get rewardAddresses(): string[] {\n    return this._rewardAddresses.map((a) => avaxUtils.format(this._network.alias, this._network.hrp, a));\n  }\n\n  /**\n   * Get the list of outputs. Amounts are expressed in absolute value.\n   */\n  get outputs(): Entry[] {\n    switch (this.type) {\n      case TransactionType.AddPermissionlessValidator:\n        return [\n          {\n            address: (\n              (this._avaxTransaction as UnsignedTx).getTx() as pvmSerial.AddPermissionlessValidatorTx\n            ).subnetValidator.validator.nodeId.toString(),\n            value: (\n              (this._avaxTransaction as UnsignedTx).getTx() as pvmSerial.AddPermissionlessValidatorTx\n            ).subnetValidator.validator.weight.toJSON(),\n          },\n        ];\n      default:\n        return [];\n    }\n  }\n\n  get fee(): TransactionFee {\n    return { fee: '0', ...this._fee };\n  }\n\n  get changeOutputs(): Entry[] {\n    return ((this._avaxTransaction as UnsignedTx).getTx() as pvmSerial.AddPermissionlessValidatorTx).baseTx.outputs.map(\n      utils.mapOutputToEntry(this._network)\n    );\n  }\n\n  get inputs(): Entry[] {\n    let inputs;\n    switch (this.type) {\n      case TransactionType.AddPermissionlessValidator:\n      default:\n        inputs = ((this._avaxTransaction as UnsignedTx).getTx() as pvmSerial.AddPermissionlessValidatorTx).baseTx\n          .inputs;\n        break;\n    }\n    return inputs.map((input) => {\n      return {\n        id: input.utxoID.txID.toString() + INPUT_SEPARATOR + input.utxoID.outputIdx.value(),\n        address: this.fromAddresses.sort().join(ADDRESS_SEPARATOR),\n        value: input.amount().toString(),\n      };\n    });\n  }\n\n  /**\n   * Avax wrapper to create signature and return it for credentials\n   * @param prv\n   * @return hexstring\n   */\n  createSignature(prv: Buffer): string {\n    const signval = utils.createSignatureAvaxBuffer(\n      this._network,\n      BufferAvax.from(this.signablePayload),\n      BufferAvax.from(prv)\n    );\n    return signval.toString('hex');\n  }\n\n  /** @inheritdoc */\n  explainTransaction(): TransactionExplanation {\n    const txJson = this.toJson();\n    const displayOrder = ['id', 'inputs', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'];\n\n    const outputAmount = txJson.outputs.reduce((p, n) => p.add(new BN(n.value)), new BN(0)).toString();\n    const changeAmount = txJson.changeOutputs.reduce((p, n) => p.add(new BN(n.value)), new BN(0)).toString();\n\n    let rewardAddresses;\n    if ([TransactionType.AddPermissionlessValidator].includes(txJson.type)) {\n      rewardAddresses = this.rewardAddresses;\n      displayOrder.splice(6, 0, 'rewardAddresses');\n    }\n\n    return {\n      displayOrder,\n      id: txJson.id,\n      inputs: txJson.inputs,\n      outputs: txJson.outputs.map((o) => ({ address: o.address, amount: o.value })),\n      outputAmount,\n      changeOutputs: txJson.changeOutputs.map((o) => ({ address: o.address, amount: o.value })),\n      changeAmount,\n      rewardAddresses,\n      fee: this.fee,\n      type: txJson.type,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,71 @@
+import { BaseTransactionBuilder } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { DecodedUtxoObj, Tx } from './iface';
+import { KeyPair } from './keyPair';
+import { Transaction } from './transaction';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected recoverSigner: boolean;
+    _signer: KeyPair[];
+    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;
+    /**
+     * Validates the threshold
+     * @param threshold
+     */
+    validateThreshold(threshold: number): void;
+    /**
+     * Check the UTXO has expected fields.
+     * @param UTXO
+     */
+    validateUtxo(value: DecodedUtxoObj): void;
+    /**
+     * Check the list of UTXOS is empty and check each UTXO.
+     * @param values
+     */
+    validateUtxos(values: DecodedUtxoObj[]): void;
+    /**
+     * Validates locktime
+     * @param locktime
+     */
+    validateLocktime(locktime: bigint): void;
+    /**
+     * 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} value
+     */
+    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;
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param {boolean}[recoverSigner=true] whether it's recovery signer
+     */
+    recoverMode(recoverSigner?: boolean): this;
+    /**
+     * fromPubKey is a list of unique addresses that correspond to the private keys that can be used to spend this output
+     * @param {string | string[]} 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;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+}
+//# 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":"AACA,OAAO,EAAE,sBAAsB,EAAyB,MAAM,sBAAsB,CAAC;AACrF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;IACpC,SAAS,CAAC,aAAa,UAAS;IACzB,OAAO,EAAE,OAAO,EAAE,CAAM;gBAEnB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAazB;;;OAGG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1C;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAMzC;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI;IAO7C;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOxC;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM9B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMtC;;;;OAIG;IACH,WAAW,CAAC,aAAa,UAAO,GAAG,IAAI;IAKvC;;;OAGG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAMjD;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAcpC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;CASlE"}

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,138 @@
+"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 avalanchejs_1 = require("@bitgo-forks/avalanchejs");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const utils_1 = __importDefault(require("./utils"));
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+        this._signer = [];
+        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.tx.baseTx;
+        if (baseTx.NetworkId.value() !== this._transaction._networkID ||
+            baseTx.BlockchainId.value() !== this._transaction._blockchainID) {
+            throw new Error('Network or blockchain is not equals');
+        }
+        this._transaction.setTransaction(tx);
+        return this;
+    }
+    // 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');
+        }
+    }
+    /**
+     * 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 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);
+    }
+    /**
+     * Validates locktime
+     * @param locktime
+     */
+    validateLocktime(locktime) {
+        if (!locktime || locktime < BigInt(0)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: locktime must be 0 or higher');
+        }
+    }
+    // endregion
+    /**
+     * 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} value
+     */
+    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(BigInt(value));
+        this._transaction._locktime = BigInt(value);
+        return this;
+    }
+    /**
+     * When using recovery key must be set here
+     * TODO: STLX-17317 recovery key signing
+     * @param {boolean}[recoverSigner=true] whether it's recovery signer
+     */
+    recoverMode(recoverSigner = true) {
+        this.recoverSigner = recoverSigner;
+        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 | string[]} 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;
+    }
+    // TODO(CR-1073):
+    // Implement:
+    //  buildImplementation
+    //  signImplementation
+    //  get transaction
+    //  set transaction
+    //  validateRawTransaction
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const [tx] = avalanchejs_1.pvmSerial.AddPermissionlessValidatorTx.fromBytes(Buffer.from(rawTransaction, 'hex'), avalanchejs_1.avmSerial.getAVMManager().getDefaultCodec());
+        // TODO(CR-1073): check if initBuilder can only use UnsignedTx and pvmSerial.BaseTx is not required
+        this.initBuilder(tx);
+        return this._transaction;
+    }
+}
+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 { avmSerial, pvmSerial, UnsignedTx } from '@bitgo-forks/avalanchejs';\nimport { BaseTransactionBuilder, BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { DecodedUtxoObj, Tx } from './iface';\nimport { KeyPair } from './keyPair';\nimport { Transaction } from './transaction';\nimport utils from './utils';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected recoverSigner = false;\n  public _signer: KeyPair[] = [];\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 as UnsignedTx).tx as pvmSerial.AddPermissionlessValidatorTx).baseTx;\n    if (\n      baseTx.NetworkId.value() !== this._transaction._networkID ||\n      baseTx.BlockchainId.value() !== this._transaction._blockchainID\n    ) {\n      throw new Error('Network or blockchain is not equals');\n    }\n    this._transaction.setTransaction(tx);\n    return this;\n  }\n\n  // region Validators\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   * 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 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   * Validates locktime\n   * @param locktime\n   */\n  validateLocktime(locktime: bigint): void {\n    if (!locktime || locktime < BigInt(0)) {\n      throw new BuildTransactionError('Invalid transaction: locktime must be 0 or higher');\n    }\n  }\n  // endregion\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} value\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(BigInt(value));\n    this._transaction._locktime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * When using recovery key must be set here\n   * TODO: STLX-17317 recovery key signing\n   * @param {boolean}[recoverSigner=true] whether it's recovery signer\n   */\n  recoverMode(recoverSigner = true): this {\n    this.recoverSigner = recoverSigner;\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 | string[]} 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  // TODO(CR-1073):\n  // Implement:\n  //  buildImplementation\n  //  signImplementation\n  //  get transaction\n  //  set transaction\n  //  validateRawTransaction\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const [tx] = pvmSerial.AddPermissionlessValidatorTx.fromBytes(\n      Buffer.from(rawTransaction, 'hex'),\n      avmSerial.getAVMManager().getDefaultCodec()\n    );\n    // TODO(CR-1073): check if initBuilder can only use UnsignedTx and pvmSerial.BaseTx is not required\n    this.initBuilder(tx);\n    return this._transaction;\n  }\n}\n"]}

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

@@ -0,0 +1,57 @@
+import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { DeprecatedTransactionBuilder } from './deprecatedTransactionBuilder';
+import { ExportInCTxBuilder } from './exportInCTxBuilder';
+import { ExportTxBuilder } from './exportTxBuilder';
+import { ImportInCTxBuilder } from './importInCTxBuilder';
+import { ImportTxBuilder } from './importTxBuilder';
+import { PermissionlessValidatorTxBuilder } from './permissionlessValidatorTxBuilder';
+import { TransactionBuilder } from './transactionBuilder';
+import { ValidatorTxBuilder } from './validatorTxBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    from(raw: string): TransactionBuilder | DeprecatedTransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): DeprecatedTransactionBuilder;
+    /**
+     * Initialize Validator builder
+     *
+     * @returns {ValidatorTxBuilder} the builder initialized
+     */
+    getValidatorBuilder(): ValidatorTxBuilder;
+    /**
+     * Initialize Permissionless Validator builder
+     *
+     * @returns {PermissionlessValidatorTxBuilder} the builder initialized
+     */
+    getPermissionlessValidatorTxBuilder(): PermissionlessValidatorTxBuilder;
+    /**
+     * 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;
+    /**
+     * Export in C chain Cross chain transfer
+     *
+     * @returns {ExportInCTxBuilder} the builder initialized
+     */
+    getExportInCBuilder(): ExportInCTxBuilder;
+    /** @inheritdoc */
+    getWalletInitializationBuilder(): DeprecatedTransactionBuilder;
+}
+//# 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":"AAQA,OAAO,EAAE,6BAA6B,EAAgB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAoB,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAI/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,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;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,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,GAAG,4BAA4B;IA6FpE,kBAAkB;IAClB,kBAAkB,IAAI,4BAA4B;IAIlD;;;;OAIG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;;;OAIG;IACH,mCAAmC,IAAI,gCAAgC;IAIvE;;;;OAIG;IACH,gBAAgB,IAAI,eAAe;IAInC;;;;OAIG;IACH,gBAAgB,IAAI,eAAe;IAInC;;;;OAIG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;;;OAIG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC,kBAAkB;IAClB,8BAA8B,IAAI,4BAA4B;CAG/D"}