@bitgo/account-lib 2.20.1 → 2.21.0-hotfix.1

package/dist/src/coin/algo/transferBuilder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const algosdk_1 = __importDefault(require("algosdk"));
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    buildAlgoTxn() {
+        return algosdk_1.default.makePaymentTxnWithSuggestedParams(this._sender, this._to, this._amount, this._closeRemainderTo, this._note, this.suggestedParams, this._reKeyTo);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        const algoTx = tx.getAlgoTransaction();
+        if (algoTx) {
+            this.amount(algoTx.amount || 0);
+            this.to({ address: algosdk_1.default.encodeAddress(algoTx.to.publicKey) });
+            if (algoTx.closeRemainderTo) {
+                this.closeRemainderTo({ address: algosdk_1.default.encodeAddress(algoTx.closeRemainderTo.publicKey) });
+            }
+        }
+        return tx;
+    }
+    validateRawTransaction(rawTransaction) {
+        const { txn: algoTxn } = utils_1.default.decodeAlgoTxn(rawTransaction);
+        if (algoTxn.type !== algosdk_1.default.TransactionType.pay) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${algoTxn.type}. Expected ${algosdk_1.default.TransactionType.pay}`);
+        }
+    }
+    validateTransaction(transaction) {
+        super.validateTransaction(transaction);
+        const validationResult = txnSchema_1.TransferTransactionSchema.validate({
+            to: this._to,
+            amount: this._amount,
+            closeRemainderTo: this._closeRemainderTo,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    /**
+     * Sets the payment receiver.
+     *
+     * @param {BaseAddress} to The receiver account
+     * @returns {TransferBuilder} This transfer builder.
+     *
+     */
+    to(to) {
+        this.validateAddress(to);
+        this._to = to.address;
+        return this;
+    }
+    /**
+     * Sets the amount of payment.
+     *
+     * @param {number} amount The amount of payment.
+     * @returns {TransferBuilder} This transfer builder.
+     */
+    amount(amount) {
+        this.validateValue(new bignumber_js_1.default(amount.toString()));
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * Sets address to transfer remainder amount on closing.
+     *
+     * @param {BaseAddress} closeRemainderTo The address for receiving remainder amount
+     * @returns {TransferBuilder} This transfer builder.
+     *
+     */
+    closeRemainderTo(closeRemainderTo) {
+        this.validateAddress(closeRemainderTo);
+        this._closeRemainderTo = closeRemainderTo.address;
+        return this;
+    }
+}
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/coin/algo/txnSchema.d.ts

@@ -0,0 +1,7 @@
+import joi from 'joi';
+export declare const BaseTransactionSchema: joi.ObjectSchema<any>;
+export declare const TransferTransactionSchema: joi.ObjectSchema<any>;
+export declare const KeyRegTxnSchema: joi.ObjectSchema<any>;
+export declare const AssetTransferTxnSchema: joi.ObjectSchema<any>;
+export declare const AssetToggleTxnSchema: joi.ObjectSchema<any>;
+//# sourceMappingURL=txnSchema.d.ts.map

package/dist/src/coin/algo/txnSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txnSchema.d.ts","sourceRoot":"","sources":["../../../../src/coin/algo/txnSchema.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAMtB,eAAO,MAAM,qBAAqB,uBAwB9B,CAAC;AAEL,eAAO,MAAM,yBAAyB,uBAOpC,CAAC;AAEH,eAAO,MAAM,eAAe,uBAiBxB,CAAC;AAEL,eAAO,MAAM,sBAAsB,uBAIjC,CAAC;AAEH,eAAO,MAAM,oBAAoB,uBAG/B,CAAC"}

package/dist/src/coin/algo/txnSchema.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetToggleTxnSchema = exports.AssetTransferTxnSchema = exports.KeyRegTxnSchema = exports.TransferTransactionSchema = exports.BaseTransactionSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+const addressSchema = joi_1.default.string().custom((addr) => utils_1.default.isValidAddress(addr));
+exports.BaseTransactionSchema = joi_1.default
+    .object({
+    fee: joi_1.default.number().required(),
+    firstRound: joi_1.default.number().positive().required(),
+    genesisHash: joi_1.default.string().base64().required(),
+    lastRound: joi_1.default.number().positive().required(),
+    sender: addressSchema.required(),
+    genesisId: joi_1.default.string().optional(),
+    lease: joi_1.default.optional(),
+    note: joi_1.default.optional(),
+    reKeyTo: joi_1.default
+        .string()
+        .custom((addr) => utils_1.default.isValidAddress(addr))
+        .optional(),
+})
+    .custom((obj) => {
+    const firstRound = obj.firstRound;
+    const lastRound = obj.lastRound;
+    if (firstRound < lastRound) {
+        return obj;
+    }
+    throw new Error('lastRound cannot be greater than or equal to firstRound');
+});
+exports.TransferTransactionSchema = joi_1.default.object({
+    amount: joi_1.default.custom((val) => typeof val === 'number' || typeof val === 'bigint').required(),
+    to: joi_1.default
+        .string()
+        .custom((addr) => utils_1.default.isValidAddress(addr))
+        .required(),
+    closeRemainderTo: joi_1.default.string().optional(),
+});
+exports.KeyRegTxnSchema = joi_1.default
+    .object({
+    voteKey: addressSchema.required(),
+    selectionKey: addressSchema.required(),
+    voteFirst: joi_1.default.number().positive().required(),
+    voteLast: joi_1.default.number().positive().required(),
+    voteKeyDilution: joi_1.default.number().positive().required(),
+    stateProofKey: addressSchema.optional(),
+})
+    .custom((obj) => {
+    const voteFirst = obj.voteFirst;
+    const voteLast = obj.voteLast;
+    if (voteFirst > voteLast) {
+        throw new sdk_core_1.InvalidTransactionError('VoteKey last round must be greater than first round');
+    }
+    return obj;
+});
+exports.AssetTransferTxnSchema = joi_1.default.object({
+    tokenId: joi_1.default.number().required(),
+    assetAmount: joi_1.default.custom((val) => typeof val === 'number' || typeof val === 'bigint').required(),
+    receiver: addressSchema.required(),
+});
+exports.AssetToggleTxnSchema = joi_1.default.object({
+    tokenId: joi_1.default.number().required(),
+    receiver: addressSchema.required(),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/coin/algo/utils.d.ts

@@ -0,0 +1,249 @@
+/// <reference types="node" />
+import algosdk from 'algosdk';
+import { Address, EncodedTx, Seed } from './ifaces';
+import { KeyPair } from './keyPair';
+import { BaseUtils } from '@bitgo/sdk-core';
+export declare class Utils implements BaseUtils {
+    /** @inheritdoc */
+    isValidAddress(address: string): boolean;
+    /** @inheritdoc */
+    isValidTransactionId(txId: string): boolean;
+    /** @inheritdoc */
+    isValidPublicKey(key: string): boolean;
+    /** @inheritdoc */
+    isValidPrivateKey(key: string): boolean;
+    /**
+     * Returns an hex string of the given buffer
+     *
+     * @param {Uint8Array} buffer - the buffer to be converted to hex
+     * @returns {string} - the hex value
+     */
+    toHex(buffer: Uint8Array): string;
+    /** @inheritdoc */
+    isValidSignature(signature: string): boolean;
+    /** @inheritdoc */
+    isValidBlockId(hash: string): boolean;
+    /**
+     * Compare two Keys
+     *
+     * @param {Uint8Array} key1 - key to be compare
+     * @param {Uint8Array} key2 - key to be compare
+     * @returns {boolean} - returns true if both keys are equal
+     */
+    areKeysEqual(key1: Uint8Array, key2: Uint8Array): boolean;
+    /**
+     * Returns a Uint8Array of the given hex string
+     *
+     * @param {string} str - the hex string to be converted
+     * @returns {string} - the Uint8Array value
+     */
+    toUint8Array(str: string): Uint8Array;
+    /**
+     * Determines whether a seed is valid.
+     *
+     * @param {string} seed - the seed to be validated
+     * @returns {boolean} - true if the seed is valid
+     */
+    isValidSeed(seed: string): boolean;
+    /**
+     * Encode an algo seed
+     *
+     * @param  {Buffer} secretKey - the valid secretKey .
+     * @returns {string} - the seed to be validated.
+     */
+    encodeSeed(secretKey: Buffer): string;
+    /**
+     * decodeSeed decodes an algo seed
+     *
+     * Decoding algo seed is same as decoding address.
+     * Latest version of algo sdk (1.9, at this writing) does not expose explicit method for decoding seed.
+     * Parameter is decoded and split into seed and checksum.
+     *
+     * @param {string} seed - hex or base64 encoded seed to be validated
+     * @returns {Seed} - validated object Seed
+     */
+    decodeSeed(seed: string): Seed;
+    /**
+     * Verifies if signature for message is valid.
+     *
+     * @param pub {Uint8Array} public key
+     * @param message {Uint8Array} signed message
+     * @param signature {Buffer} signature to verify
+     * @returns {Boolean} true if signature is valid.
+     */
+    verifySignature(message: Uint8Array, signature: Buffer, pub: Uint8Array): boolean;
+    /**
+     * Transforms an Ed25519 public key into an algorand address.
+     *
+     * @param {Uint8Array} pk The Ed25519 public key.
+     * @see https://developer.algorand.org/docs/features/accounts/#transformation-public-key-to-algorand-address
+     *
+     * @returns {string} The algorand address.
+     */
+    publicKeyToAlgoAddress(pk: Uint8Array): string;
+    /**
+     * Checks if a unsigned algo transaction can be decoded.
+     *
+     * @param {Uint8Array} txn The encoded unsigned transaction.
+     * @returns {boolean} true if the transaction can be decoded, otherwise false
+     */
+    protected isDecodableUnsignedAlgoTxn(txn: Uint8Array): boolean;
+    /**
+     * Checks if a signed algo transaction can be decoded.
+     *
+     * @param {Uint8Array} txn The encoded signed transaction.
+     * @returns {boolean} true if the transaction can be decoded, otherwise false
+     */
+    protected isDecodableSignedTransaction(txn: Uint8Array): boolean;
+    /**
+     * Decodes a signed or unsigned algo transaction.
+     *
+     * @param {Uint8Array | string} txnBytes The encoded unsigned or signed txn.
+     * @returns {EncodedTx} The decoded transaction.
+     */
+    decodeAlgoTxn(txnBytes: Uint8Array | string): EncodedTx;
+    /**
+     * Try to decode a signed Algo transaction
+     * @param buffer the encoded transaction
+     * @returns { EncodedTx } the decoded signed transaction
+     * @throws error if it is not a valid encoded signed transaction
+     */
+    tryToDecodeSignedTransaction(buffer: Buffer): EncodedTx;
+    /**
+     * Try to decode an unsigned Algo transaction
+     * @param buffer the encoded transaction
+     * @returns {EncodedTx} the decoded unsigned transaction
+     * @throws error if it is not a valid encoded unsigned transaction
+     */
+    tryToDecodeUnsignedTransaction(buffer: Buffer): EncodedTx;
+    encodeObj(obj: Record<string | number | symbol, any>): Uint8Array;
+    /**
+     * decodeObj takes a Uint8Array and returns its javascript obj
+     * @param o - Uint8Array to decode
+     * @returns object
+     */
+    decodeObj(o: ArrayLike<number>): unknown;
+    /**
+     * secretKeyToMnemonic takes an Algorant secret key and returns the corresponding mnemonic
+     *
+     * @param sk - Algorant secret key
+     * @return Secret key is associated mnemonic
+     */
+    secretKeyToMnemonic(sk: Buffer): string;
+    /**
+     * seedFromMnemonic converts a mnemonic generated using this library into the source key used to create it
+     * It returns an error if the passed mnemonic has an incorrect checksum, if the number of words is unexpected, or if one
+     * of the passed words is not found in the words list
+     *
+     * @param mnemonic - 25 words mnemonic
+     * @returns 32 bytes long seed
+     */
+    seedFromMnemonic(mnemonic: string): Uint8Array;
+    /**
+     * keyPairFromSeed generates an object with secretKey and publicKey using the algosdk
+     * @param seed 32 bytes long seed
+     * @returns KeyPair
+     */
+    keyPairFromSeed(seed: Uint8Array): KeyPair;
+    /**
+     * Generate a new `KeyPair` object from the given private key.
+     *
+     * @param base64PrivateKey 64 bytes long privateKey
+     * @returns KeyPair
+     */
+    protected createKeyPair(base64PrivateKey: Uint8Array): KeyPair;
+    /**
+     * decodePrivateKey generates a seed with a mnemonic and using algosdk.
+     *
+     * @param seed 32 bytes long seed
+     * @returns mnemonic - 25 words mnemonic - 25 words mnemonic
+     */
+    protected mnemonicFromSeed(seed: Uint8Array): string;
+    /**
+     * Validates the key with the stellar-sdk
+     *
+     * @param publicKey
+     * @returns boolean
+     */
+    protected isValidEd25519PublicKeyStellar(publicKey: string): boolean;
+    /**
+     * Decodes the key with the stellar-sdk
+     *
+     * @param publicKey
+     * @returns Buffer
+     */
+    protected decodeEd25519PublicKeyStellar(publicKey: string): Buffer;
+    /**
+     * Convert a stellar seed to algorand encoding
+     *
+     * @param seed
+     * @returns string the encoded seed
+     */
+    convertFromStellarSeed(seed: string): string;
+    /**
+     * Returns an address encoded with algosdk
+     *
+     * @param addr
+     * @returns string
+     */
+    encodeAddress(addr: Uint8Array): string;
+    /**
+     * Return an address decoded with algosdk
+     *
+     * @param addr
+     * @returns Address
+     */
+    decodeAddress(addr: string): Address;
+    /**
+     * Converts an address into an ALGO one
+     * If the given data is a Stellar address or public key, it is converted to ALGO address.
+     *
+     * @param addressOrPubKey an ALGO address, or an Stellar address or public key
+     * @returns address algo address string
+     */
+    stellarAddressToAlgoAddress(addressOrPubKey: string): string;
+    /**
+     * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
+     *
+     * @param {number} version mutlisig version
+     * @param {number} threshold multisig threshold
+     * @param {string[]} addrs list of Algorand addresses
+     * @returns {string} human readable Algorand address.
+     */
+    multisigAddress(version: number, threshold: number, addrs: string[]): string;
+    /**
+     * generateAccount generates un account with a secretKey and an address
+     *
+     * Function has not params
+     * @returns Account
+     */
+    generateAccount(): algosdk.Account;
+    generateAccountFromSeed(seed: Uint8Array): algosdk.Account;
+    /**
+     * Generates Tx ID from an encoded multisig transaction
+     *
+     * This is done because of a change made on version 1.10.1 on algosdk so method txID() only supports SignedTransaction type.
+     * (https://github.com/algorand/js-algorand-sdk/blob/develop/CHANGELOG.md#1101)
+     *
+     * @param {string} txBase64 - encoded base64 multisig transaction
+     * @returns {string} - transaction ID
+     */
+    getMultisigTxID(txBase64: string): string;
+    /**
+     * Determines if a given transaction data is to enable or disable a token
+     * @param amount the amount in transaction
+     * @param from the originated address
+     * @param to the target address
+     * @param closeRemainderTo (optional) address to send remaining units in originated address
+     * @returns 'enableToken' or 'disableToken'
+     */
+    getTokenTxType(amount: string, from: string, to: string, closeRemainderTo?: string): string;
+    /**
+     * Validate if the key is a valid base64 string
+     * @param key the key to validate
+     */
+    validateBase64(key: string): void;
+}
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/coin/algo/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/coin/algo/utils.ts"],"names":[],"mappings":"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"}