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

package/dist/src/lib/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-beta/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/lib/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/lib/txnSchema.d.ts.map

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

@@ -0,0 +1,254 @@
+import algosdk from 'algosdk';
+import { Address, EncodedTx, Seed } from './ifaces';
+import { KeyPair } from './keyPair';
+import { BaseUtils } from '@bitgo-beta/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;
+    /**
+     Transforms a decrypted Ed25519 private key into an algorand address.
+     @param {string} privateKey The Ed25519 private key.
+     @returns {string} The algorand address.
+     **/
+    privateKeyToAlgoAddress(privateKey: string): 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/lib/utils.d.ts.map

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