@bitgo/account-lib 2.20.0-rc.22 → 2.20.0-rc.23

package/dist/src/coin/cspr/transactionBuilder.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = exports.DEFAULT_N = exports.DEFAULT_M = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const casper_js_sdk_1 = require("casper-js-sdk");
+const lodash_1 = __importDefault(require("lodash"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transaction_1 = require("./transaction");
+const keyPair_1 = require("./keyPair");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+exports.DEFAULT_M = 3;
+exports.DEFAULT_N = 2;
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.transaction = new transaction_1.Transaction(_coinConfig);
+        this._multiSignerKeyPairs = [];
+        this._signatures = [];
+        this._chainName = this.coinName() === 'cspr' ? constants_1.DEFAULT_CHAIN_NAMES.mainnet : constants_1.DEFAULT_CHAIN_NAMES.testnet;
+    }
+    // region Base Builder
+    /** @inheritdoc */
+    async buildImplementation() {
+        const deployParams = this.getDeployParams();
+        const session = this.getSession();
+        const payment = casper_js_sdk_1.DeployUtil.standardPayment(lodash_1.default.parseInt(this._fee.gasLimit));
+        let cTransaction = this.transaction.casperTx || casper_js_sdk_1.DeployUtil.makeDeploy(deployParams, session, payment);
+        // Cannot add arguments to an already signed deploy.
+        if (cTransaction.approvals.length === 0) {
+            this._session.extraArguments.forEach((extraArgument, extraArgumentName) => {
+                if (!cTransaction.session.getArgByName(extraArgumentName)) {
+                    cTransaction = casper_js_sdk_1.DeployUtil.addArgToDeploy(cTransaction, extraArgumentName, extraArgument);
+                }
+            });
+        }
+        this.transaction.casperTx = cTransaction;
+        this.processSigning();
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new transaction_1.Transaction(this._coinConfig);
+        const jsonTransaction = JSON.parse(rawTransaction);
+        tx.casperTx = casper_js_sdk_1.DeployUtil.deployFromJson(jsonTransaction).unwrap();
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        this.checkDuplicatedKeys(key);
+        const signer = new keyPair_1.KeyPair({ prv: key.key });
+        // Signing the transaction is an operation that relies on all the data being set,
+        // so we set the source here and leave the actual signing for the build step
+        this._multiSignerKeyPairs.push(signer);
+        return this.transaction;
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx) {
+        this.transaction = tx;
+        this.transaction.loadPreviousSignatures();
+        const txData = tx.toJson();
+        this.fee(txData.fee);
+        this.source({ address: txData.from });
+        this.expiration(txData.expiration || constants_1.TRANSACTION_EXPIRATION);
+    }
+    // endregion
+    // region Common builder methods
+    /**
+     * Set the transaction fees
+     *
+     * @param {BaseFee} fee The maximum gas to pay
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    fee(fee) {
+        this.validateValue(new bignumber_js_1.default(fee.gasLimit));
+        this._fee = fee;
+        return this;
+    }
+    /**
+     * Set the transaction source
+     *
+     * @param {BaseAddress} address The source account
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    source(address) {
+        this.validateAddress(address);
+        this._source = address;
+        return this;
+    }
+    /**
+     * Set the transaction expirationTime
+     *
+     * @param {string} expirationTime The transaction expirationTime
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    expiration(expirationTime) {
+        const transactionExpiration = new bignumber_js_1.default(expirationTime);
+        if (transactionExpiration.isNaN() || transactionExpiration.isGreaterThan(constants_1.TRANSACTION_EXPIRATION)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction expiration');
+        }
+        this.validateValue(transactionExpiration);
+        this._expiration = transactionExpiration.toNumber();
+        return this;
+    }
+    /**
+     * Set an external transaction signature
+     *
+     * @param {string} signature Hex encoded signature string
+     * @param {KeyPair} keyPair The public key keypair that was used to create the signature
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    signature(signature, keyPair) {
+        // if we already have a signature for this key pair, just update it
+        for (const oldSignature of this._signatures) {
+            if (oldSignature.keyPair.getKeys().pub === keyPair.getKeys().pub) {
+                oldSignature.signature = signature;
+                return this;
+            }
+        }
+        // otherwise add the new signature
+        this._signatures.push({ signature, keyPair });
+        return this;
+    }
+    nodeChainName(chainName) {
+        this._chainName = chainName;
+        return this;
+    }
+    // endregion
+    // region Validators
+    /** @inheritdoc */
+    validateAddress(address) {
+        if (!utils_1.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        if (!new keyPair_1.KeyPair({ prv: key.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 {
+            casper_js_sdk_1.DeployUtil.deployFromJson(JSON.parse(rawTransaction));
+        }
+        catch (e) {
+            throw new sdk_core_1.ParseTransactionError('There was an error parsing the JSON string');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this.validateMandatoryFields();
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    /**
+     * Validates that the mandatory fields are defined
+     */
+    validateMandatoryFields() {
+        this.validateFee();
+        this.validateSource();
+    }
+    /**
+     * Validates that the fee field is defined
+     */
+    validateFee() {
+        if (this._fee === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing fee');
+        }
+        if (!this._fee.gasLimit) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing gas limit');
+        }
+        try {
+            this.validateValue(new bignumber_js_1.default(this._fee.gasLimit));
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Invalid gas limit');
+        }
+    }
+    /**
+     * Validates that the source field is defined
+     */
+    validateSource() {
+        if (this._source === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing source');
+        }
+        this.validateAddress(this._source);
+    }
+    /**
+     * Validates that the given key is not already in this._multiSignerKeyPairs
+     *
+     * @param {BaseKey} key - The key to check
+     */
+    checkDuplicatedKeys(key) {
+        this._multiSignerKeyPairs.forEach((_sourceKeyPair) => {
+            if (_sourceKeyPair.getKeys().prv === key.key) {
+                throw new sdk_core_1.SigningError('Repeated sign: ' + key.key);
+            }
+            // Try to get extended keys in order to validate them
+            let xprv;
+            try {
+                xprv = _sourceKeyPair.getExtendedKeys().xprv;
+            }
+            catch (err) {
+                return;
+            }
+            if (xprv && xprv === key.key) {
+                throw new sdk_core_1.SigningError('Repeated sign: ' + key.key);
+            }
+        });
+    }
+    // endregion
+    // region Getters and Setters
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /**
+     * Get the chain name for the coin environment
+     */
+    get chainName() {
+        return this._chainName;
+    }
+    // endregion
+    // region auxiliaryMethods
+    /**
+     * Generate a DeployParams instance with the transaction data
+     *
+     * @returns {DeployUtil.DeployParams}
+     */
+    getDeployParams() {
+        const gasPrice = this._fee.gasPrice ? lodash_1.default.parseInt(this._fee.gasPrice) : undefined;
+        return new casper_js_sdk_1.DeployUtil.DeployParams(casper_js_sdk_1.CLPublicKey.fromHex(this._source.address), this._chainName, gasPrice, this._expiration || constants_1.TRANSACTION_EXPIRATION);
+    }
+    /**
+     * Generate the session for the Deploy according to the transactionType.
+     *
+     * @returns {DeployUtil.ExecutableDeployItem}
+     */
+    getSession() {
+        let session;
+        switch (this.transaction.type) {
+            case sdk_core_1.TransactionType.Send:
+                const transferSession = this._session;
+                session = casper_js_sdk_1.DeployUtil.ExecutableDeployItem.newTransferWithOptionalTransferId(transferSession.amount, transferSession.target, undefined, transferSession.id);
+                break;
+            case sdk_core_1.TransactionType.WalletInitialization:
+            case sdk_core_1.TransactionType.StakingLock:
+            case sdk_core_1.TransactionType.StakingUnlock:
+                const moduleBytesSession = this._session;
+                session = casper_js_sdk_1.DeployUtil.ExecutableDeployItem.newModuleBytes(moduleBytesSession.moduleBytes, moduleBytesSession.args);
+                break;
+            default:
+                throw new sdk_core_1.BuildTransactionError('Transaction Type error');
+        }
+        return session;
+    }
+    /**
+     * Checks whether the transaction has the owner signature
+     *
+     * @param {string} pub - public key of the signer
+     * @returns {boolean} true if the pub key already signed th transaction
+     * @private
+     */
+    isTransactionSignedByPub(pub) {
+        return (lodash_1.default.findIndex(this.transaction.casperTx.approvals, (approval) => {
+            const approvalSigner = utils_1.removeAlgoPrefixFromHexValue(approval.signer);
+            return approvalSigner === pub;
+        }) !== -1);
+    }
+    /**
+     * Add signatures to the transaction
+     *
+     * @private
+     */
+    processSigning() {
+        for (const keyPair of this._multiSignerKeyPairs) {
+            // Add signature if it's not already in the deploy
+            if (!this.isTransactionSignedByPub(keyPair.getKeys().pub)) {
+                this.transaction.sign(keyPair);
+            }
+        }
+        for (const { signature, keyPair } of this._signatures) {
+            // Add signature if it's not already in the deploy
+            if (!this.isTransactionSignedByPub(keyPair.getKeys().pub)) {
+                this.transaction.addSignature(signature, keyPair);
+            }
+        }
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../../src/coin/cspr/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { DeployUtil, CLPublicKey as PublicKey } from 'casper-js-sdk';\nimport _ from 'lodash';\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  InvalidTransactionError,\n  ParseTransactionError,\n  SigningError,\n  TransactionType,\n} from '@bitgo/sdk-core';\nimport { Transaction } from './transaction';\nimport { KeyPair } from './keyPair';\nimport {\n  Fee,\n  CasperModuleBytesTransaction,\n  CasperTransferTransaction,\n  CasperDelegateTransaction,\n  SignatureData,\n} from './ifaces';\nimport { isValidAddress, removeAlgoPrefixFromHexValue } from './utils';\nimport { DEFAULT_CHAIN_NAMES, TRANSACTION_EXPIRATION } from './constants';\n\nexport const DEFAULT_M = 3;\nexport const DEFAULT_N = 2;\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _source: BaseAddress;\n  protected _fee: Fee;\n  private _transaction: Transaction;\n  protected _session: CasperTransferTransaction | CasperModuleBytesTransaction | CasperDelegateTransaction;\n  protected _expiration: number;\n  protected _multiSignerKeyPairs: KeyPair[];\n  protected _signatures: SignatureData[];\n  protected _chainName: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this.transaction = new Transaction(_coinConfig);\n    this._multiSignerKeyPairs = [];\n    this._signatures = [];\n    this._chainName = this.coinName() === 'cspr' ? DEFAULT_CHAIN_NAMES.mainnet : DEFAULT_CHAIN_NAMES.testnet;\n  }\n\n  // region Base Builder\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    const deployParams = this.getDeployParams();\n    const session = this.getSession();\n\n    const payment = DeployUtil.standardPayment(_.parseInt(this._fee.gasLimit));\n\n    let cTransaction = this.transaction.casperTx || DeployUtil.makeDeploy(deployParams, session, payment);\n\n    // Cannot add arguments to an already signed deploy.\n    if (cTransaction.approvals.length === 0) {\n      this._session.extraArguments.forEach((extraArgument, extraArgumentName) => {\n        if (!cTransaction.session.getArgByName(extraArgumentName)) {\n          cTransaction = DeployUtil.addArgToDeploy(cTransaction, extraArgumentName, extraArgument);\n        }\n      });\n    }\n\n    this.transaction.casperTx = cTransaction;\n\n    this.processSigning();\n\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    const jsonTransaction = JSON.parse(rawTransaction);\n    tx.casperTx = DeployUtil.deployFromJson(jsonTransaction).unwrap();\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    this.checkDuplicatedKeys(key);\n    const signer = new KeyPair({ prv: key.key });\n\n    // Signing the transaction is an operation that relies on all the data being set,\n    // so we set the source here and leave the actual signing for the build step\n    this._multiSignerKeyPairs.push(signer);\n    return this.transaction;\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: Transaction): void {\n    this.transaction = tx;\n    this.transaction.loadPreviousSignatures();\n    const txData = tx.toJson();\n    this.fee(txData.fee);\n    this.source({ address: txData.from });\n    this.expiration(txData.expiration || TRANSACTION_EXPIRATION);\n  }\n\n  // endregion\n\n  // region Common builder methods\n\n  /**\n   * Set the transaction fees\n   *\n   * @param {BaseFee} fee The maximum gas to pay\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  fee(fee: Fee): this {\n    this.validateValue(new BigNumber(fee.gasLimit));\n    this._fee = fee;\n    return this;\n  }\n\n  /**\n   * Set the transaction source\n   *\n   * @param {BaseAddress} address The source account\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  source(address: BaseAddress): this {\n    this.validateAddress(address);\n    this._source = address;\n    return this;\n  }\n\n  /**\n   * Set the transaction expirationTime\n   *\n   * @param {string} expirationTime The transaction expirationTime\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  expiration(expirationTime: number): this {\n    const transactionExpiration = new BigNumber(expirationTime);\n    if (transactionExpiration.isNaN() || transactionExpiration.isGreaterThan(TRANSACTION_EXPIRATION)) {\n      throw new BuildTransactionError('Invalid transaction expiration');\n    }\n    this.validateValue(transactionExpiration);\n    this._expiration = transactionExpiration.toNumber();\n    return this;\n  }\n\n  /**\n   * Set an external transaction signature\n   *\n   * @param {string} signature Hex encoded signature string\n   * @param {KeyPair} keyPair The public key keypair that was used to create the signature\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  signature(signature: string, keyPair: KeyPair): this {\n    // if we already have a signature for this key pair, just update it\n    for (const oldSignature of this._signatures) {\n      if (oldSignature.keyPair.getKeys().pub === keyPair.getKeys().pub) {\n        oldSignature.signature = signature;\n        return this;\n      }\n    }\n\n    // otherwise add the new signature\n    this._signatures.push({ signature, keyPair });\n    return this;\n  }\n\n  nodeChainName(chainName: string): this {\n    this._chainName = chainName;\n    return this;\n  }\n\n  // endregion\n\n  // region Validators\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress): void {\n    if (!isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address ' + address.address);\n    }\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    if (!new KeyPair({ prv: key.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      DeployUtil.deployFromJson(JSON.parse(rawTransaction));\n    } catch (e) {\n      throw new ParseTransactionError('There was an error parsing the JSON string');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    this.validateMandatoryFields();\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   * Validates that the mandatory fields are defined\n   */\n  validateMandatoryFields(): void {\n    this.validateFee();\n    this.validateSource();\n  }\n\n  /**\n   * Validates that the fee field is defined\n   */\n  private validateFee(): void {\n    if (this._fee === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing fee');\n    }\n    if (!this._fee.gasLimit) {\n      throw new BuildTransactionError('Invalid transaction: missing gas limit');\n    }\n    try {\n      this.validateValue(new BigNumber(this._fee.gasLimit));\n    } catch (e) {\n      throw new BuildTransactionError('Invalid gas limit');\n    }\n  }\n\n  /**\n   * Validates that the source field is defined\n   */\n  private validateSource(): void {\n    if (this._source === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing source');\n    }\n    this.validateAddress(this._source);\n  }\n\n  /**\n   * Validates that the given key is not already in this._multiSignerKeyPairs\n   *\n   * @param {BaseKey} key - The key to check\n   */\n  private checkDuplicatedKeys(key: BaseKey) {\n    this._multiSignerKeyPairs.forEach((_sourceKeyPair) => {\n      if (_sourceKeyPair.getKeys().prv === key.key) {\n        throw new SigningError('Repeated sign: ' + key.key);\n      }\n      // Try to get extended keys in order to validate them\n      let xprv;\n      try {\n        xprv = _sourceKeyPair.getExtendedKeys().xprv;\n      } catch (err) {\n        return;\n      }\n      if (xprv && xprv === key.key) {\n        throw new SigningError('Repeated sign: ' + key.key);\n      }\n    });\n  }\n\n  // endregion\n\n  // region Getters and Setters\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /**\n   * Get the chain name for the coin environment\n   */\n  public get chainName(): string {\n    return this._chainName;\n  }\n  // endregion\n\n  // region auxiliaryMethods\n  /**\n   * Generate a DeployParams instance with the transaction data\n   *\n   * @returns {DeployUtil.DeployParams}\n   */\n  private getDeployParams(): DeployUtil.DeployParams {\n    const gasPrice = this._fee.gasPrice ? _.parseInt(this._fee.gasPrice) : undefined;\n    return new DeployUtil.DeployParams(\n      PublicKey.fromHex(this._source.address),\n      this._chainName,\n      gasPrice,\n      this._expiration || TRANSACTION_EXPIRATION,\n    );\n  }\n\n  /**\n   * Generate the session for the Deploy according to the transactionType.\n   *\n   * @returns {DeployUtil.ExecutableDeployItem}\n   */\n  private getSession(): DeployUtil.ExecutableDeployItem {\n    let session;\n    switch (this.transaction.type) {\n      case TransactionType.Send:\n        const transferSession = this._session as CasperTransferTransaction;\n        session = DeployUtil.ExecutableDeployItem.newTransferWithOptionalTransferId(\n          transferSession.amount,\n          transferSession.target,\n          undefined,\n          transferSession.id,\n        );\n        break;\n      case TransactionType.WalletInitialization:\n      case TransactionType.StakingLock:\n      case TransactionType.StakingUnlock:\n        const moduleBytesSession = this._session as CasperModuleBytesTransaction;\n        session = DeployUtil.ExecutableDeployItem.newModuleBytes(\n          moduleBytesSession.moduleBytes,\n          moduleBytesSession.args,\n        );\n        break;\n      default:\n        throw new BuildTransactionError('Transaction Type error');\n    }\n    return session;\n  }\n\n  /**\n   * Checks whether the transaction has the owner signature\n   *\n   * @param {string} pub - public key of the signer\n   * @returns {boolean} true if the pub key already signed th transaction\n   * @private\n   */\n  private isTransactionSignedByPub(pub: string): boolean {\n    return (\n      _.findIndex(this.transaction.casperTx.approvals, (approval) => {\n        const approvalSigner = removeAlgoPrefixFromHexValue(approval.signer);\n        return approvalSigner === pub;\n      }) !== -1\n    );\n  }\n\n  /**\n   * Add signatures to the transaction\n   *\n   * @private\n   */\n  private processSigning(): void {\n    for (const keyPair of this._multiSignerKeyPairs) {\n      // Add signature if it's not already in the deploy\n      if (!this.isTransactionSignedByPub(keyPair.getKeys().pub)) {\n        this.transaction.sign(keyPair);\n      }\n    }\n    for (const { signature, keyPair } of this._signatures) {\n      // Add signature if it's not already in the deploy\n      if (!this.isTransactionSignedByPub(keyPair.getKeys().pub)) {\n        this.transaction.addSignature(signature, keyPair);\n      }\n    }\n  }\n  // endregion\n}\n"]}

package/dist/src/coin/cspr/transactionBuilderFactory.d.ts

@@ -0,0 +1,46 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseTransactionBuilderFactory } from '@bitgo/sdk-core';
+import { WalletInitializationBuilder } from './walletInitializationBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { DelegateBuilder } from './delegateBuilder';
+import { UndelegateBuilder } from './undelegateBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx?: Transaction): WalletInitializationBuilder;
+    /**
+     * Initialize an undelegate builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {UndelegateBuilder} the builder initialized
+     */
+    getUndelegateBuilder(tx?: Transaction): UndelegateBuilder;
+    /**
+     * Initialize an delegate builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {DelegateBuilder} the builder initialized
+     */
+    getDelegateBuilder(tx?: Transaction): DelegateBuilder;
+    /** @inheritDoc */
+    getTransferBuilder(tx?: Transaction): TransferBuilder;
+    /** @inheritDoc */
+    from(raw: string): TransactionBuilder;
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    private initializeBuilder;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {any} rawTransaction - Transaction in any format
+     */
+    private validateRawTransaction;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../../src/coin/cspr/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EACL,6BAA6B,EAI9B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,8BAA8B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAI7E;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,iBAAiB;IAIzD;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAyBrC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;CAU/B"}

package/dist/src/coin/cspr/transactionBuilderFactory.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const casper_js_sdk_1 = require("casper-js-sdk");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const walletInitializationBuilder_1 = require("./walletInitializationBuilder");
+const transferBuilder_1 = require("./transferBuilder");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const delegateBuilder_1 = require("./delegateBuilder");
+const undelegateBuilder_1 = require("./undelegateBuilder");
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx) {
+        return this.initializeBuilder(tx, new walletInitializationBuilder_1.WalletInitializationBuilder(this._coinConfig));
+    }
+    /**
+     * Initialize an undelegate builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {UndelegateBuilder} the builder initialized
+     */
+    getUndelegateBuilder(tx) {
+        return this.initializeBuilder(tx, new undelegateBuilder_1.UndelegateBuilder(this._coinConfig));
+    }
+    /**
+     * Initialize an delegate builder
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @returns {DelegateBuilder} the builder initialized
+     */
+    getDelegateBuilder(tx) {
+        return this.initializeBuilder(tx, new delegateBuilder_1.DelegateBuilder(this._coinConfig));
+    }
+    /** @inheritDoc */
+    getTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new transferBuilder_1.TransferBuilder(this._coinConfig));
+    }
+    /** @inheritDoc */
+    from(raw) {
+        this.validateRawTransaction(raw);
+        const tx = new transaction_1.Transaction(this._coinConfig);
+        const deployJson = JSON.parse(raw);
+        try {
+            tx.casperTx = casper_js_sdk_1.DeployUtil.deployFromJson(deployJson).unwrap();
+        }
+        catch (e) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid transaction: ' + e);
+        }
+        const casperDeployType = utils_1.getDeployType(tx.casperTx.session);
+        switch (casperDeployType) {
+            case sdk_core_1.TransactionType.Send:
+                return this.getTransferBuilder(tx);
+            case sdk_core_1.TransactionType.WalletInitialization:
+                return this.getWalletInitializationBuilder(tx);
+            case sdk_core_1.TransactionType.StakingLock:
+                return this.getDelegateBuilder(tx);
+            case sdk_core_1.TransactionType.StakingUnlock:
+                return this.getUndelegateBuilder(tx);
+            default:
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction ' + tx.casperTx);
+        }
+    }
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {any} rawTransaction - Transaction in any format
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction: Undefined');
+        }
+        try {
+            JSON.parse(rawTransaction);
+        }
+        catch (e) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction format');
+        }
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../../src/coin/cspr/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { DeployUtil } from 'casper-js-sdk';\nimport {\n  BaseTransactionBuilderFactory,\n  TransactionType,\n  InvalidTransactionError,\n  ParseTransactionError,\n} from '@bitgo/sdk-core';\nimport { WalletInitializationBuilder } from './walletInitializationBuilder';\nimport { TransferBuilder } from './transferBuilder';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { getDeployType } from './utils';\nimport { DelegateBuilder } from './delegateBuilder';\nimport { UndelegateBuilder } from './undelegateBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(tx?: Transaction): WalletInitializationBuilder {\n    return this.initializeBuilder(tx, new WalletInitializationBuilder(this._coinConfig));\n  }\n\n  /**\n   * Initialize an undelegate builder\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @returns {UndelegateBuilder} the builder initialized\n   */\n  getUndelegateBuilder(tx?: Transaction): UndelegateBuilder {\n    return this.initializeBuilder(tx, new UndelegateBuilder(this._coinConfig));\n  }\n\n  /**\n   * Initialize an delegate builder\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @returns {DelegateBuilder} the builder initialized\n   */\n  getDelegateBuilder(tx?: Transaction): DelegateBuilder {\n    return this.initializeBuilder(tx, new DelegateBuilder(this._coinConfig));\n  }\n\n  /** @inheritDoc */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritDoc */\n  from(raw: string): TransactionBuilder {\n    this.validateRawTransaction(raw);\n    const tx = new Transaction(this._coinConfig);\n    const deployJson = JSON.parse(raw);\n    try {\n      tx.casperTx = DeployUtil.deployFromJson(deployJson).unwrap();\n    } catch (e) {\n      throw new InvalidTransactionError('Invalid transaction: ' + e);\n    }\n\n    const casperDeployType = getDeployType(tx.casperTx.session);\n    switch (casperDeployType) {\n      case TransactionType.Send:\n        return this.getTransferBuilder(tx);\n      case TransactionType.WalletInitialization:\n        return this.getWalletInitializationBuilder(tx);\n      case TransactionType.StakingLock:\n        return this.getDelegateBuilder(tx);\n      case TransactionType.StakingUnlock:\n        return this.getUndelegateBuilder(tx);\n      default:\n        throw new InvalidTransactionError('Invalid transaction ' + tx.casperTx);\n    }\n  }\n\n  /**\n   * Initialize the builder with the given transaction\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @param {TransactionBuilder} builder - the builder to be initialized\n   * @returns {TransactionBuilder} the builder initialized\n   */\n  private initializeBuilder<T extends TransactionBuilder>(tx: Transaction | undefined, builder: T): T {\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param {any} rawTransaction - Transaction in any format\n   */\n  private validateRawTransaction(rawTransaction: string) {\n    if (!rawTransaction) {\n      throw new ParseTransactionError('Invalid raw transaction: Undefined');\n    }\n    try {\n      JSON.parse(rawTransaction);\n    } catch (e) {\n      throw new ParseTransactionError('Invalid raw transaction format');\n    }\n  }\n}\n"]}

package/dist/src/coin/cspr/transferBuilder.d.ts

@@ -0,0 +1,39 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseKey } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+export declare class TransferBuilder extends TransactionBuilder {
+    private _toAddress;
+    private _amount;
+    private _transferId;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+    /**
+     * Set the destination address where the funds will be sent,
+     *
+     * @param {string} address the address to transfer funds to
+     * @returns {TransferBuilder} the builder with the new parameter set
+     */
+    to(address: string): this;
+    /**
+     * Set the amount to be transferred
+     *
+     * @param {string} amount amount to transfer in motes (1 Cspr equals 1,000,000,000 motes)
+     * @returns {TransferBuilder} the builder with the new parameter set
+     */
+    amount(amount: string): this;
+    /**
+     * Set transfer id that acts as a transaction identifier (similar to memo id for Stellar)
+     *
+     * @param {number} id transfer id
+     * @returns {TransferBuilder} the builder with the new parameter set
+     */
+    transferId(id: number | string): this;
+    validateMandatoryFields(): void;
+}
+//# sourceMappingURL=transferBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/cspr/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EACL,OAAO,EAKR,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,kBAAkB,EAAa,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAW5C,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAkB;gBAEzB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAgB3D,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAWlC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAQvD;;;;;OAKG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQzB;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAWrC,uBAAuB,IAAI,IAAI;CAgBhC"}