@bitgo-beta/sdk-coin-algo 1.1.0

package/dist/src/lib/transaction.js

@@ -0,0 +1,251 @@
+"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 algosdk_1 = __importDefault(require("algosdk"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+const keyPair_1 = require("./keyPair");
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._numberOfRequiredSigners = 0;
+        this._signers = [];
+    }
+    /** @inheritdoc */
+    canSign({ key }) {
+        if (this._numberOfRequiredSigners === 0) {
+            return false;
+        }
+        if (this._numberOfRequiredSigners === 1) {
+            const kp = new keyPair_1.KeyPair({ prv: key });
+            const addr = kp.getAddress();
+            if (addr === this._sender) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    sender(address) {
+        this._sender = address;
+    }
+    /**
+     * Signs transaction.
+     *
+     * @param {KeyPair} keyPair Signer keys.
+     */
+    sign(keyPair) {
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        if (this._numberOfRequiredSigners === 1) {
+            this.signSingle(keyPair[0]);
+        }
+        else if (this._numberOfRequiredSigners > 1) {
+            this.signMultiSig(keyPair);
+        }
+    }
+    /**
+     * Signs transaction.
+     *
+     * @param {KeyPair} keyPair Signer keys.
+     */
+    signSingle(keyPair) {
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        const signKey = Buffer.from(keyPair.getSigningKey()).toString('hex');
+        if (signKey) {
+            this._signedTransaction = algosdk_1.default.signTransaction(this._algoTransaction, utils_1.default.toUint8Array(signKey)).blob;
+        }
+        else {
+            throw new sdk_core_1.InvalidKey('Private key undefined');
+        }
+    }
+    /**
+     * Signs multisig transaction.
+     *
+     * @param {KeyPair} keyPair Signers keys.
+     */
+    signMultiSig(keyPair) {
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        if (this._signers.length === 0) {
+            throw new sdk_core_1.SigningError('Signers not specified for multisig');
+        }
+        if (keyPair.length === 0) {
+            throw new sdk_core_1.SigningError('Keypair not specified for multisig');
+        }
+        const multiSigOptions = {
+            version: 1,
+            threshold: this._numberOfRequiredSigners,
+            addrs: this._signers,
+        };
+        const msigAddress = algosdk_1.default.multisigAddress(multiSigOptions);
+        this._algoTransaction.from = algosdk_1.default.decodeAddress(msigAddress);
+        // Check if it is a signed or unsigned tx.
+        // If unsigned, sign it using first keypair and then append next signatures.
+        // If signed, appending next signatures.
+        let signedTx = this._signedTransaction
+            ? this._signedTransaction
+            : algosdk_1.default.signMultisigTransaction(this._algoTransaction, multiSigOptions, keyPair.shift().getSigningKey()).blob;
+        keyPair.forEach((kp) => {
+            signedTx = algosdk_1.default.appendSignMultisigTransaction(signedTx, multiSigOptions, kp.getSigningKey()).blob;
+        });
+        this._signedTransaction = signedTx;
+    }
+    set signedTransaction(txn) {
+        this._signedTransaction = txn;
+    }
+    get numberOfRequiredSigners() {
+        return this._numberOfRequiredSigners;
+    }
+    /**
+     * Sets the number of signers required for signing this transaction.
+     *
+     * @param {number} num Threshold number of signers.
+     */
+    setNumberOfRequiredSigners(num) {
+        this._numberOfRequiredSigners = num;
+    }
+    set signers(addrs) {
+        this._signers = addrs;
+    }
+    get signers() {
+        return this._signers;
+    }
+    set signedBy(signer) {
+        this._signedBy = signer;
+    }
+    get signedBy() {
+        return this._signedBy;
+    }
+    /**
+     * Sets algo transaction.
+     *
+     * @param {algosdk.Transaction} tx
+     */
+    setAlgoTransaction(tx) {
+        this._algoTransaction = tx;
+    }
+    /**
+     * Get underlaying algo transaction.
+     *
+     * @returns {algosdk.Transaction}
+     */
+    getAlgoTransaction() {
+        return this._algoTransaction;
+    }
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    setTransactionType(transactionType) {
+        this._type = transactionType;
+    }
+    estimateSize() {
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        return this._algoTransaction.estimateSize();
+    }
+    /** @inheritdoc */
+    toBroadcastFormat() {
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        if (this._signedTransaction && this._signedTransaction.length > 0) {
+            return this._signedTransaction;
+        }
+        else {
+            return algosdk_1.default.encodeUnsignedTransaction(this._algoTransaction);
+        }
+    }
+    /** @inheritdoc */
+    toJson() {
+        var _a, _b;
+        if (!this._algoTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        const result = {
+            id: this._algoTransaction.txID(),
+            type: (_a = this._algoTransaction.type) === null || _a === void 0 ? void 0 : _a.toString(),
+            from: algosdk_1.default.encodeAddress(this._algoTransaction.from.publicKey),
+            fee: this._algoTransaction.fee,
+            firstRound: this._algoTransaction.firstRound,
+            lastRound: this._algoTransaction.lastRound,
+            note: this._algoTransaction.note,
+            tokenId: (_b = this._algoTransaction) === null || _b === void 0 ? void 0 : _b.assetIndex,
+            genesisID: this._algoTransaction.genesisID,
+            genesisHash: this._algoTransaction.genesisHash.toString('base64'),
+        };
+        if (this._algoTransaction.closeRemainderTo) {
+            result.closeRemainderTo = algosdk_1.default.encodeAddress(this._algoTransaction.closeRemainderTo.publicKey);
+        }
+        if (this.type === sdk_core_1.TransactionType.Send) {
+            result.to = algosdk_1.default.encodeAddress(this._algoTransaction.to.publicKey);
+            result.amount = this._algoTransaction.amount.toString();
+        }
+        if (this.type === sdk_core_1.TransactionType.WalletInitialization) {
+            if (!this._algoTransaction.nonParticipation) {
+                if (this._algoTransaction.voteKey &&
+                    this._algoTransaction.selectionKey &&
+                    this._algoTransaction.voteFirst &&
+                    this._algoTransaction.voteLast &&
+                    this._algoTransaction.voteKeyDilution) {
+                    result.voteKey = this._algoTransaction.voteKey.toString('base64');
+                    result.selectionKey = this._algoTransaction.selectionKey.toString('base64');
+                    result.voteFirst = this._algoTransaction.voteFirst;
+                    result.voteLast = this._algoTransaction.voteLast;
+                    result.voteKeyDilution = this._algoTransaction.voteKeyDilution;
+                    if (this._algoTransaction.stateProofKey) {
+                        result.stateProofKey = this._algoTransaction.stateProofKey.toString('base64');
+                    }
+                }
+            }
+            else {
+                result.nonParticipation = this._algoTransaction.nonParticipation;
+            }
+        }
+        if (result.type === 'axfer' && result.to && result.amount) {
+            result.txType = utils_1.default.getTokenTxType(result.amount, result.from, result.to, result.closeRemainderTo);
+            result.tokenName = this._coinConfig.suffix;
+        }
+        return result;
+    }
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs() {
+        if (!this._algoTransaction) {
+            return;
+        }
+        if (this.type === sdk_core_1.TransactionType.Send) {
+            this._outputs = [
+                {
+                    address: algosdk_1.default.encodeAddress(this._algoTransaction.to.publicKey),
+                    value: this._algoTransaction.amount.toString(),
+                    coin: this._coinConfig.name,
+                },
+            ];
+            this._inputs = [
+                {
+                    address: algosdk_1.default.encodeAddress(this._algoTransaction.from.publicKey),
+                    value: this._algoTransaction.amount.toString(),
+                    coin: this._coinConfig.name,
+                },
+            ];
+        }
+    }
+}
+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 { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport algosdk from 'algosdk';\nimport {\n  BaseTransaction,\n  TransactionType,\n  BaseKey,\n  InvalidTransactionError,\n  InvalidKey,\n  SigningError,\n} from '@bitgo-beta/sdk-core';\nimport utils from './utils';\nimport { KeyPair } from './keyPair';\nimport { TxData } from './ifaces';\n\nexport class Transaction extends BaseTransaction {\n  private _algoTransaction?: algosdk.Transaction;\n  private _signedTransaction?: Uint8Array;\n  private _numberOfRequiredSigners: number;\n  private _sender: string;\n  private _signers: string[];\n  private _signedBy: string[];\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._numberOfRequiredSigners = 0;\n    this._signers = [];\n  }\n\n  /** @inheritdoc */\n  canSign({ key }: BaseKey): boolean {\n    if (this._numberOfRequiredSigners === 0) {\n      return false;\n    }\n    if (this._numberOfRequiredSigners === 1) {\n      const kp = new KeyPair({ prv: key });\n      const addr = kp.getAddress();\n      if (addr === this._sender) {\n        return true;\n      } else {\n        return false;\n      }\n    } else {\n      return true;\n    }\n  }\n\n  sender(address: string): void {\n    this._sender = address;\n  }\n\n  /**\n   * Signs transaction.\n   *\n   * @param {KeyPair} keyPair Signer keys.\n   */\n  sign(keyPair: KeyPair[]): void {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    if (this._numberOfRequiredSigners === 1) {\n      this.signSingle(keyPair[0]);\n    } else if (this._numberOfRequiredSigners > 1) {\n      this.signMultiSig(keyPair);\n    }\n  }\n\n  /**\n   * Signs transaction.\n   *\n   * @param {KeyPair} keyPair Signer keys.\n   */\n  private signSingle(keyPair: KeyPair): void {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    const signKey = Buffer.from(keyPair.getSigningKey()).toString('hex');\n    if (signKey) {\n      this._signedTransaction = algosdk.signTransaction(this._algoTransaction, utils.toUint8Array(signKey)).blob;\n    } else {\n      throw new InvalidKey('Private key undefined');\n    }\n  }\n\n  /**\n   * Signs multisig transaction.\n   *\n   * @param {KeyPair} keyPair Signers keys.\n   */\n  private signMultiSig(keyPair: KeyPair[]): void {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    if (this._signers.length === 0) {\n      throw new SigningError('Signers not specified for multisig');\n    }\n    if (keyPair.length === 0) {\n      throw new SigningError('Keypair not specified for multisig');\n    }\n    const multiSigOptions = {\n      version: 1,\n      threshold: this._numberOfRequiredSigners,\n      addrs: this._signers,\n    };\n    const msigAddress = algosdk.multisigAddress(multiSigOptions);\n    this._algoTransaction.from = algosdk.decodeAddress(msigAddress);\n\n    // Check if it is a signed or unsigned tx.\n    // If unsigned, sign it using first keypair and then append next signatures.\n    // If signed, appending next signatures.\n    let signedTx = this._signedTransaction\n      ? this._signedTransaction\n      : algosdk.signMultisigTransaction(this._algoTransaction, multiSigOptions, keyPair.shift()!.getSigningKey()).blob;\n\n    keyPair.forEach((kp) => {\n      signedTx = algosdk.appendSignMultisigTransaction(signedTx, multiSigOptions, kp.getSigningKey()).blob;\n    });\n    this._signedTransaction = signedTx;\n  }\n\n  set signedTransaction(txn: Uint8Array) {\n    this._signedTransaction = txn;\n  }\n\n  get numberOfRequiredSigners(): number {\n    return this._numberOfRequiredSigners;\n  }\n\n  /**\n   * Sets the number of signers required for signing this transaction.\n   *\n   * @param {number} num Threshold number of signers.\n   */\n  setNumberOfRequiredSigners(num: number): void {\n    this._numberOfRequiredSigners = num;\n  }\n\n  set signers(addrs: string[]) {\n    this._signers = addrs;\n  }\n\n  get signers(): string[] {\n    return this._signers;\n  }\n\n  set signedBy(signer: string[]) {\n    this._signedBy = signer;\n  }\n\n  get signedBy(): string[] {\n    return this._signedBy;\n  }\n\n  /**\n   * Sets algo transaction.\n   *\n   * @param {algosdk.Transaction} tx\n   */\n\n  setAlgoTransaction(tx: algosdk.Transaction): void {\n    this._algoTransaction = tx;\n  }\n\n  /**\n   * Get underlaying algo transaction.\n   *\n   * @returns {algosdk.Transaction}\n   */\n\n  getAlgoTransaction(): algosdk.Transaction | undefined {\n    return this._algoTransaction;\n  }\n\n  /**\n   * Set the transaction type.\n   *\n   * @param {TransactionType} transactionType The transaction type to be set.\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  estimateSize(): number {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n\n    return this._algoTransaction.estimateSize();\n  }\n\n  /** @inheritdoc */\n  toBroadcastFormat(): Uint8Array {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    if (this._signedTransaction && this._signedTransaction.length > 0) {\n      return this._signedTransaction;\n    } else {\n      return algosdk.encodeUnsignedTransaction(this._algoTransaction);\n    }\n  }\n\n  /** @inheritdoc */\n  toJson(): TxData {\n    if (!this._algoTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    const result: TxData = {\n      id: this._algoTransaction.txID(),\n      type: this._algoTransaction.type?.toString(),\n      from: algosdk.encodeAddress(this._algoTransaction.from.publicKey),\n      fee: this._algoTransaction.fee,\n      firstRound: this._algoTransaction.firstRound,\n      lastRound: this._algoTransaction.lastRound,\n      note: this._algoTransaction.note,\n      tokenId: this._algoTransaction?.assetIndex,\n      genesisID: this._algoTransaction.genesisID,\n      genesisHash: this._algoTransaction.genesisHash.toString('base64'),\n    };\n    if (this._algoTransaction.closeRemainderTo) {\n      result.closeRemainderTo = algosdk.encodeAddress(this._algoTransaction.closeRemainderTo.publicKey);\n    }\n    if (this.type === TransactionType.Send) {\n      result.to = algosdk.encodeAddress(this._algoTransaction.to.publicKey);\n      result.amount = this._algoTransaction.amount.toString();\n    }\n    if (this.type === TransactionType.WalletInitialization) {\n      if (!this._algoTransaction.nonParticipation) {\n        if (\n          this._algoTransaction.voteKey &&\n          this._algoTransaction.selectionKey &&\n          this._algoTransaction.voteFirst &&\n          this._algoTransaction.voteLast &&\n          this._algoTransaction.voteKeyDilution\n        ) {\n          result.voteKey = this._algoTransaction.voteKey.toString('base64');\n          result.selectionKey = this._algoTransaction.selectionKey.toString('base64');\n          result.voteFirst = this._algoTransaction.voteFirst;\n          result.voteLast = this._algoTransaction.voteLast;\n          result.voteKeyDilution = this._algoTransaction.voteKeyDilution;\n          if (this._algoTransaction.stateProofKey) {\n            result.stateProofKey = this._algoTransaction.stateProofKey.toString('base64');\n          }\n        }\n      } else {\n        result.nonParticipation = this._algoTransaction.nonParticipation;\n      }\n    }\n    if (result.type === 'axfer' && result.to && result.amount) {\n      result.txType = utils.getTokenTxType(result.amount, result.from, result.to, result.closeRemainderTo);\n      result.tokenName = this._coinConfig.suffix;\n    }\n    return result;\n  }\n\n  /**\n   * Load the input and output data on this transaction.\n   */\n  loadInputsAndOutputs(): void {\n    if (!this._algoTransaction) {\n      return;\n    }\n    if (this.type === TransactionType.Send) {\n      this._outputs = [\n        {\n          address: algosdk.encodeAddress(this._algoTransaction.to.publicKey),\n          value: this._algoTransaction.amount.toString(),\n          coin: this._coinConfig.name,\n        },\n      ];\n\n      this._inputs = [\n        {\n          address: algosdk.encodeAddress(this._algoTransaction.from.publicKey),\n          value: this._algoTransaction.amount.toString(),\n          coin: this._coinConfig.name,\n        },\n      ];\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,204 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import BigNumber from 'bignumber.js';
+import algosdk from 'algosdk';
+import { Transaction } from './transaction';
+import { KeyPair } from './keyPair';
+import { BaseAddress, BaseFee, BaseKey, BaseTransactionBuilder, TransactionType } from '@bitgo-beta/sdk-core';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected _keyPairs: KeyPair[];
+    protected _fee: number;
+    protected _isFlatFee: boolean;
+    protected _sender: string;
+    protected _genesisHash: string;
+    protected _genesisId: string;
+    protected _firstRound: number;
+    protected _lastRound: number;
+    protected _lease?: Uint8Array;
+    protected _note?: Uint8Array;
+    protected _reKeyTo?: string;
+    protected _suggestedParams: algosdk.SuggestedParams;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /**
+     * Sets the fee.
+     *
+     * The minimum fee is 1000 microalgos.
+     *
+     * @param {BaseFee} feeObj The amount to pay to the fee sink denoted in microalgos
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    fee(feeObj: BaseFee): this;
+    /**
+     * Sets whether the fee is a flat fee.
+     *
+     * A flat fee is the fee for the entire transaction whereas a normal fee
+     * is a fee for every byte in the transaction.
+     *
+     * @param {boolean} isFlatFee Whether the fee should be specified as a flat fee.
+     * @returns {TransactionBuilder} This transaction builder.
+     */
+    isFlatFee(isFlatFee: boolean): this;
+    /**
+     * Sets the transaction sender.
+     *
+     * @param {BaseAddress} sender The sender account
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    sender(sender: BaseAddress): this;
+    /**
+     * Sets the genesis id.
+     *
+     * @param {string} genesisId The genesis id.
+     * @example "mainnet-v1.0"
+     *
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    genesisId(genesisId: string): this;
+    /**
+     * Sets the genesis hash.
+     *
+     * The genesis hash must be base64 encoded.
+     *
+     * @param {string} genesisHash The genesis hash.
+     * @example "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8="
+     *
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    genesisHash(genesisHash: string): this;
+    /**
+     * Sets the genesis id and hash to mainnet.
+     *
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/mainnet/#genesis-id
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/mainnet/#genesis-hash
+     */
+    mainnet(): this;
+    /**
+     * Sets the genesis id and hash to testnet.
+     *
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/testnet/#genesis-id
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/testnet/#genesis-hash
+     */
+    testnet(): this;
+    /**
+     * Sets the genesis id and hash to betanet.
+     *
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/betanet/#genesis-id
+     * @see https://developer.algorand.org/docs/reference/algorand-networks/betanet/#genesis-hash
+     */
+    betanet(): this;
+    /**
+     * Sets the first round.
+     *
+     * @param {number} round The first protocol round on which this txn is valid.
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    firstRound(round: number): this;
+    /**
+     * Sets the last round.
+     *
+     * @param {number} round The first protocol round on which this txn is valid.
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    lastRound(round: number): this;
+    /**
+     * Sets the lease on the transaction.
+     *
+     * A lease is a mutex on the transaction that prevents any other transaction
+     * from being sent with the same lease until the prior transaction's last
+     * round has passed.
+     *
+     * @param {Uint8Array} lease The lease to put the transaction.
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    lease(lease: Uint8Array): this;
+    /**
+     * Sets the note for the transaction.
+     *
+     * @param {Uint8Array} note Arbitrary data for sender to store.
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    note(note: Uint8Array): this;
+    /**
+     * Sets the authorized address.
+     *
+     * The authorized asset will be used to authorize all future transactions.
+     *
+     * @param {BaseAddress} authorizer The address to delegate authorization authority to.
+     * @returns {TransactionBuilder} This transaction builder.
+     *
+     * @see https://developer.algorand.org/docs/reference/transactions/
+     */
+    reKeyTo(authorizer: BaseAddress): this;
+    /** @inheritdoc */
+    validateAddress({ address }: BaseAddress): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Builds the algorand transaction.
+     */
+    protected abstract buildAlgoTxn(): algosdk.Transaction;
+    /**
+     * The transaction type.
+     */
+    protected abstract get transactionType(): TransactionType;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: Uint8Array | string): Transaction;
+    /** @inheritdoc */
+    protected signImplementation({ key }: BaseKey): Transaction;
+    numberOfSigners(num: number): this;
+    setSigners(addrs: string | string[]): this;
+    /**
+     * Sets the number of signers required to sign the transaction.
+     *
+     * The number of signers cannot be set to a negative value.
+     *
+     * @param {number} n The number of signers.
+     * @returns {TransactionBuilder} This transaction builder.
+     */
+    numberOfRequiredSigners(n: number): this;
+    /**
+     * @inheritdoc
+     * @see https://developer.algorand.org/docs/features/accounts/#transformation-private-key-to-base64-private-key
+     */
+    validateKey({ key }: BaseKey): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: Uint8Array | string): void;
+    /** @inheritdoc */
+    validateTransaction(_: Transaction): void;
+    private validateBaseFields;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    /** @inheritdoc */
+    protected set transaction(transaction: Transaction);
+    /**
+     * Convenience method to retrieve the algosdk suggested parameters.
+     *
+     * @returns {algosdk.SuggestedParams} The algosdk suggested parameters.
+     */
+    protected get suggestedParams(): algosdk.SuggestedParams;
+}
+//# 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":"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"}