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

package/dist/src/lib/keyPair.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyPair = void 0;
+const algosdk_1 = __importStar(require("algosdk"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+class KeyPair extends sdk_core_1.Ed25519KeyPair {
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param { KeyPairOptions } source Either a master seed, a private key, or a public key
+     */
+    constructor(source) {
+        super(source);
+    }
+    /** @inheritdoc */
+    recordKeysFromPrivateKeyInProtocolFormat(prv) {
+        const decodedSeed = utils_1.default.decodeSeed(prv);
+        const bufferFromSeed = Buffer.from(decodedSeed.seed);
+        return utils_1.default.keyPairFromSeed(bufferFromSeed).keyPair;
+    }
+    /** @inheritdoc */
+    recordKeysFromPublicKeyInProtocolFormat(pub) {
+        const publicKey = algosdk_1.default.decodeAddress(pub).publicKey;
+        return { pub: utils_1.default.toHex(publicKey) };
+    }
+    /** @inheritdoc */
+    getAddress() {
+        return (0, algosdk_1.encodeAddress)(utils_1.default.toUint8Array(this.keyPair.pub));
+    }
+    /** @inheritdoc */
+    getKeys() {
+        // TODO(https://bitgoinc.atlassian.net/browse/STLX-6062): refactor this method
+        // should return the pub and prv in the Algorand encoded format
+        const result = { pub: this.keyPair.pub };
+        if (this.keyPair.prv) {
+            result.prv = this.keyPair.prv;
+        }
+        return result;
+    }
+    /**
+     * Getting the base64 private key for signing an algo transaction.
+     *
+     * @returns {Uint8Array} base64 private key
+     * @see https://developer.algorand.org/docs/features/accounts/#transformation-private-key-to-base64-private-key
+     */
+    getSigningKey() {
+        if (!this.keyPair.prv) {
+            throw new sdk_core_1.InvalidKey('Private key undefined');
+        }
+        return utils_1.default.toUint8Array(this.keyPair.prv + this.keyPair.pub);
+    }
+}
+exports.KeyPair = KeyPair;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,104 @@
+import algosdk from 'algosdk';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+export declare class KeyRegistrationBuilder extends TransactionBuilder {
+    protected _voteKey: string;
+    protected _selectionKey: string;
+    protected _voteFirst: number;
+    protected _voteLast: number;
+    protected _voteKeyDilution: number;
+    protected _nonParticipation: boolean;
+    protected _stateProofKey: string;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /**
+     * Sets the vote key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The root participation public key. See Generate a Participation Key to learn more.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    voteKey(key: string): KeyRegistrationBuilder;
+    /**
+     * Sets the selection key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The VRF public key for the account.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    selectionKey(key: string): KeyRegistrationBuilder;
+    /**
+     * Sets the stateProof key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The stateproof key. See consensus for more information.
+     * https://developer.algorand.org/docs/get-details/algorand_consensus/?from_query=state#state-proof-keys
+     */
+    stateProofKey(key: string): KeyRegistrationBuilder;
+    /**
+     *Sets the vote first round
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {number} round The first round that the participation key is valid. Not to be confused with the FirstValid round of the keyreg transaction.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    voteFirst(round: number): KeyRegistrationBuilder;
+    /**
+     * Sets the vote last round
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * A recommended range is 3,000,000 rounds.
+     *
+     * @param {number} round No theoretical limit.
+     * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/
+     */
+    voteLast(round: number): KeyRegistrationBuilder;
+    /**
+     * Sets the vote key dilution
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * Defaults to 10,000
+     *
+     * @param {number} size [10000]. To reduce the size of the participation key, set the key dilution value to roughly the square root of the range that the partkey is valid for.
+     * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/#generate-the-participation-key-with-goal
+     * @param size
+     */
+    voteKeyDilution(size?: number): KeyRegistrationBuilder;
+    /**
+     * Sets the non participation flag
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {boolean} nonParticipation All new Algorand accounts are participating by default.
+     * This means that they earn rewards. Mark an account nonparticipating by setting this value to true and this account
+     * will no longer earn rewards NEVER.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    nonParticipation(nonParticipation: boolean): KeyRegistrationBuilder;
+    protected buildAlgoTxn(): algosdk.Transaction;
+    private buildOfflineKeyRegTransaction;
+    private buildOnlineKeyRegTransaction;
+    private buildNonParticipationKeyRegTransaction;
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: Uint8Array | string): Transaction;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: Uint8Array | string): void;
+    private isNonParticipationKeyRegAlgoSDKTransaction;
+    private isNonParticipationKeyRegAccountLibTransaction;
+    private isOnlineKeyRegAlgoSDKTransaction;
+    private isOnlineKeyRegAccountLibTransaction;
+    private isOfflineKeyRegAlgoSDKTransaction;
+    private isOfflineKeyRegAccountLibTransaction;
+    /** @inheritdoc */
+    validateTransaction(transaction: Transaction): void;
+    private validateFields;
+}
+//# sourceMappingURL=keyRegistrationBuilder.d.ts.map

package/dist/src/lib/keyRegistrationBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyRegistrationBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/keyRegistrationBuilder.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAA2B,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;IACnC,SAAS,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACrC,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC;gBAErB,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB;IAK5C;;;;;;;OAOG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB;IAKjD;;;;;;;OAOG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB;IAMlD;;;;;;;OAOG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB;IAOhD;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB;IAO/C;;;;;;;;;;OAUG;IACH,eAAe,CAAC,IAAI,SAAQ,GAAG,sBAAsB;IAOrD;;;;;;;;;OASG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,OAAO,GAAG,sBAAsB;IAMnE,SAAS,CAAC,YAAY,IAAI,OAAO,CAAC,WAAW;IAQ7C,OAAO,CAAC,6BAA6B;IAarC,OAAO,CAAC,4BAA4B;IAgBpC,OAAO,CAAC,sCAAsC;IAe9C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,UAAU,GAAG,MAAM,GAAG,WAAW;IAqB9E,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI;IAqBjE,OAAO,CAAC,0CAA0C;IAIlD,OAAO,CAAC,6CAA6C;IAIrD,OAAO,CAAC,gCAAgC;IAMxC,OAAO,CAAC,mCAAmC;IAI3C,OAAO,CAAC,iCAAiC;IAYzC,OAAO,CAAC,oCAAoC;IAY5C,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IA6BnD,OAAO,CAAC,cAAc;CAqBvB"}

package/dist/src/lib/keyRegistrationBuilder.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyRegistrationBuilder = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const algosdk_1 = __importDefault(require("algosdk"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+class KeyRegistrationBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    /**
+     * Sets the vote key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The root participation public key. See Generate a Participation Key to learn more.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    voteKey(key) {
+        this._voteKey = key;
+        return this;
+    }
+    /**
+     * Sets the selection key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The VRF public key for the account.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    selectionKey(key) {
+        this._selectionKey = key;
+        return this;
+    }
+    /**
+     * Sets the stateProof key
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {string} key The stateproof key. See consensus for more information.
+     * https://developer.algorand.org/docs/get-details/algorand_consensus/?from_query=state#state-proof-keys
+     */
+    stateProofKey(key) {
+        utils_1.default.validateBase64(key);
+        this._stateProofKey = key;
+        return this;
+    }
+    /**
+     *Sets the vote first round
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {number} round The first round that the participation key is valid. Not to be confused with the FirstValid round of the keyreg transaction.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    voteFirst(round) {
+        this.validateValue(new bignumber_js_1.default(round));
+        this._voteFirst = round;
+        return this;
+    }
+    /**
+     * Sets the vote last round
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * A recommended range is 3,000,000 rounds.
+     *
+     * @param {number} round No theoretical limit.
+     * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/
+     */
+    voteLast(round) {
+        this.validateValue(new bignumber_js_1.default(round));
+        this._voteLast = round;
+        return this;
+    }
+    /**
+     * Sets the vote key dilution
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * Defaults to 10,000
+     *
+     * @param {number} size [10000]. To reduce the size of the participation key, set the key dilution value to roughly the square root of the range that the partkey is valid for.
+     * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/#generate-the-participation-key-with-goal
+     * @param size
+     */
+    voteKeyDilution(size = 10000) {
+        this.validateValue(new bignumber_js_1.default(size));
+        this._voteKeyDilution = size;
+        return this;
+    }
+    /**
+     * Sets the non participation flag
+     *
+     * @returns {KeyRegistrationBuilder} This Key Registration builder.
+     *
+     * @param {boolean} nonParticipation All new Algorand accounts are participating by default.
+     * This means that they earn rewards. Mark an account nonparticipating by setting this value to true and this account
+     * will no longer earn rewards NEVER.
+     * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction
+     */
+    nonParticipation(nonParticipation) {
+        this._nonParticipation = nonParticipation;
+        return this;
+    }
+    buildAlgoTxn() {
+        return this.isOfflineKeyRegAccountLibTransaction()
+            ? this.buildOfflineKeyRegTransaction()
+            : this.isNonParticipationKeyRegAccountLibTransaction()
+                ? this.buildNonParticipationKeyRegTransaction()
+                : this.buildOnlineKeyRegTransaction();
+    }
+    buildOfflineKeyRegTransaction() {
+        return algosdk_1.default.makeKeyRegistrationTxnWithSuggestedParams(this._sender, this._note, undefined, // voteKey param
+        undefined, // selectionKey param
+        undefined, // voteFirst param
+        undefined, // voteLast param
+        undefined, // voteKeyDilution param
+        this.suggestedParams);
+    }
+    buildOnlineKeyRegTransaction() {
+        return algosdk_1.default.makeKeyRegistrationTxnWithSuggestedParams(this._sender, this._note, this._voteKey, this._selectionKey, this._voteFirst, this._voteLast, this._voteKeyDilution, this.suggestedParams, undefined, // reKeyTo param
+        undefined, // nonParticipation param
+        this._stateProofKey);
+    }
+    buildNonParticipationKeyRegTransaction() {
+        return algosdk_1.default.makeKeyRegistrationTxnWithSuggestedParams(this._sender, this._note, undefined, // voteKey param
+        undefined, // selectionKey param
+        undefined, // voteFirst param
+        undefined, // voteLast param
+        undefined, // voteKeyDilution param
+        this.suggestedParams, this._reKeyTo, true // nonParticipation param
+        );
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.WalletInitialization;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        const algoTxn = tx.getAlgoTransaction();
+        if (algoTxn) {
+            if (this.isNonParticipationKeyRegAlgoSDKTransaction(algoTxn)) {
+                this.nonParticipation(!!algoTxn.nonParticipation);
+            }
+            else if (this.isOnlineKeyRegAlgoSDKTransaction(algoTxn)) {
+                this.voteKey(algoTxn.voteKey.toString('base64'));
+                this.selectionKey(algoTxn.selectionKey.toString('base64'));
+                this.voteFirst(algoTxn.voteFirst);
+                this.voteLast(algoTxn.voteLast);
+                this.voteKeyDilution(algoTxn.voteKeyDilution);
+                if (algoTxn.stateProofKey) {
+                    this.stateProofKey(algoTxn.stateProofKey.toString('base64'));
+                }
+            }
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        const decodeTxn = utils_1.default.decodeAlgoTxn(rawTransaction);
+        const algoTxn = decodeTxn.txn;
+        if (algoTxn.type !== algosdk_1.default.TransactionType.keyreg) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${algoTxn.type}. Expected ${algosdk_1.default.TransactionType.keyreg}`);
+        }
+        if (this.isOnlineKeyRegAlgoSDKTransaction(algoTxn)) {
+            this.validateFields(algoTxn.voteKey.toString('base64'), algoTxn.selectionKey.toString('base64'), algoTxn.voteFirst, algoTxn.voteLast, algoTxn.voteKeyDilution, algoTxn.stateProofKey && algoTxn.stateProofKey.toString('base64'));
+        }
+    }
+    isNonParticipationKeyRegAlgoSDKTransaction(algoTxn) {
+        return !!algoTxn.nonParticipation;
+    }
+    isNonParticipationKeyRegAccountLibTransaction() {
+        return !!this._nonParticipation;
+    }
+    isOnlineKeyRegAlgoSDKTransaction(algoTxn) {
+        return !(this.isOfflineKeyRegAlgoSDKTransaction(algoTxn) || this.isNonParticipationKeyRegAlgoSDKTransaction(algoTxn));
+    }
+    isOnlineKeyRegAccountLibTransaction() {
+        return !(this.isOfflineKeyRegAccountLibTransaction() || this.isNonParticipationKeyRegAccountLibTransaction());
+    }
+    isOfflineKeyRegAlgoSDKTransaction(algoTxn) {
+        return (!algoTxn.voteKey &&
+            !algoTxn.selectionKey &&
+            !algoTxn.voteFirst &&
+            !algoTxn.voteLast &&
+            !algoTxn.voteKeyDilution &&
+            !algoTxn.stateProofKey &&
+            !algoTxn.nonParticipation);
+    }
+    isOfflineKeyRegAccountLibTransaction() {
+        return (!this._voteKey &&
+            !this._selectionKey &&
+            !this._voteFirst &&
+            !this._voteLast &&
+            !this._voteKeyDilution &&
+            !this._stateProofKey &&
+            !this._nonParticipation);
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        super.validateTransaction(transaction);
+        if (this.isOnlineKeyRegAccountLibTransaction()) {
+            // invalid offline will reach here
+            this.validateFields(this._voteKey, this._selectionKey, this._voteFirst, this._voteLast, this._voteKeyDilution, this._stateProofKey);
+        }
+        else {
+            // offline or nonparticipation transaction
+            if (this._voteKey ||
+                this._selectionKey ||
+                this._voteFirst ||
+                this._voteLast ||
+                this._voteKeyDilution ||
+                this._stateProofKey) {
+                throw new sdk_core_1.InvalidTransactionError('VoteKey, SelectionKey, VoteFirst, VoteLast, VoteKeyDilution, StateProofKey fields cannot be set when offline or nonparticipation is set');
+            }
+        }
+    }
+    validateFields(voteKey, selectionKey, voteFirst, voteLast, voteKeyDilution, stateProofKey) {
+        const validationResult = txnSchema_1.KeyRegTxnSchema.validate({
+            voteKey,
+            selectionKey,
+            voteFirst,
+            voteLast,
+            voteKeyDilution,
+            stateProofKey,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+}
+exports.KeyRegistrationBuilder = KeyRegistrationBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyRegistrationBuilder.js","sourceRoot":"","sources":["../../../src/lib/keyRegistrationBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\nimport algosdk from 'algosdk';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionType, InvalidTransactionError } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { KeyRegTxnSchema } from './txnSchema';\nimport Utils from './utils';\n\nexport class KeyRegistrationBuilder extends TransactionBuilder {\n  protected _voteKey: string;\n  protected _selectionKey: string;\n  protected _voteFirst: number;\n  protected _voteLast: number;\n  protected _voteKeyDilution: number;\n  protected _nonParticipation: boolean;\n  protected _stateProofKey: string;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n  }\n\n  /**\n   * Sets the vote key\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * @param {string} key The root participation public key. See Generate a Participation Key to learn more.\n   * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction\n   */\n  voteKey(key: string): KeyRegistrationBuilder {\n    this._voteKey = key;\n    return this;\n  }\n\n  /**\n   * Sets the selection key\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * @param {string} key The VRF public key for the account.\n   * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction\n   */\n  selectionKey(key: string): KeyRegistrationBuilder {\n    this._selectionKey = key;\n    return this;\n  }\n\n  /**\n   * Sets the stateProof key\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * @param {string} key The stateproof key. See consensus for more information.\n   * https://developer.algorand.org/docs/get-details/algorand_consensus/?from_query=state#state-proof-keys\n   */\n  stateProofKey(key: string): KeyRegistrationBuilder {\n    Utils.validateBase64(key);\n    this._stateProofKey = key;\n    return this;\n  }\n\n  /**\n   *Sets the vote first round\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * @param {number} round The first round that the participation key is valid. Not to be confused with the FirstValid round of the keyreg transaction.\n   * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction\n   */\n  voteFirst(round: number): KeyRegistrationBuilder {\n    this.validateValue(new BigNumber(round));\n    this._voteFirst = round;\n\n    return this;\n  }\n\n  /**\n   * Sets the vote last round\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * A recommended range is 3,000,000 rounds.\n   *\n   * @param {number} round No theoretical limit.\n   * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/\n   */\n  voteLast(round: number): KeyRegistrationBuilder {\n    this.validateValue(new BigNumber(round));\n    this._voteLast = round;\n\n    return this;\n  }\n\n  /**\n   * Sets the vote key dilution\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * Defaults to 10,000\n   *\n   * @param {number} size [10000]. To reduce the size of the participation key, set the key dilution value to roughly the square root of the range that the partkey is valid for.\n   * https://developer.algorand.org/docs/run-a-node/participate/generate_keys/#generate-the-participation-key-with-goal\n   * @param size\n   */\n  voteKeyDilution(size = 10000): KeyRegistrationBuilder {\n    this.validateValue(new BigNumber(size));\n    this._voteKeyDilution = size;\n\n    return this;\n  }\n\n  /**\n   * Sets the non participation flag\n   *\n   * @returns {KeyRegistrationBuilder} This Key Registration builder.\n   *\n   * @param {boolean} nonParticipation All new Algorand accounts are participating by default.\n   * This means that they earn rewards. Mark an account nonparticipating by setting this value to true and this account\n   * will no longer earn rewards NEVER.\n   * https://developer.algorand.org/docs/reference/transactions/#key-registration-transaction\n   */\n  nonParticipation(nonParticipation: boolean): KeyRegistrationBuilder {\n    this._nonParticipation = nonParticipation;\n\n    return this;\n  }\n\n  protected buildAlgoTxn(): algosdk.Transaction {\n    return this.isOfflineKeyRegAccountLibTransaction()\n      ? this.buildOfflineKeyRegTransaction()\n      : this.isNonParticipationKeyRegAccountLibTransaction()\n      ? this.buildNonParticipationKeyRegTransaction()\n      : this.buildOnlineKeyRegTransaction();\n  }\n\n  private buildOfflineKeyRegTransaction(): algosdk.Transaction {\n    return algosdk.makeKeyRegistrationTxnWithSuggestedParams(\n      this._sender,\n      this._note,\n      undefined, // voteKey param\n      undefined, // selectionKey param\n      undefined, // voteFirst param\n      undefined, // voteLast param\n      undefined, // voteKeyDilution param\n      this.suggestedParams\n    );\n  }\n\n  private buildOnlineKeyRegTransaction(): algosdk.Transaction {\n    return algosdk.makeKeyRegistrationTxnWithSuggestedParams(\n      this._sender,\n      this._note,\n      this._voteKey,\n      this._selectionKey,\n      this._voteFirst,\n      this._voteLast,\n      this._voteKeyDilution,\n      this.suggestedParams,\n      undefined, // reKeyTo param\n      undefined, // nonParticipation param\n      this._stateProofKey\n    );\n  }\n\n  private buildNonParticipationKeyRegTransaction(): algosdk.Transaction {\n    return algosdk.makeKeyRegistrationTxnWithSuggestedParams(\n      this._sender,\n      this._note,\n      undefined, // voteKey param\n      undefined, // selectionKey param\n      undefined, // voteFirst param\n      undefined, // voteLast param\n      undefined, // voteKeyDilution param\n      this.suggestedParams,\n      this._reKeyTo,\n      true // nonParticipation param\n    );\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.WalletInitialization;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: Uint8Array | string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    const algoTxn = tx.getAlgoTransaction();\n\n    if (algoTxn) {\n      if (this.isNonParticipationKeyRegAlgoSDKTransaction(algoTxn)) {\n        this.nonParticipation(!!algoTxn.nonParticipation);\n      } else if (this.isOnlineKeyRegAlgoSDKTransaction(algoTxn)) {\n        this.voteKey(algoTxn.voteKey.toString('base64'));\n        this.selectionKey(algoTxn.selectionKey.toString('base64'));\n        this.voteFirst(algoTxn.voteFirst);\n        this.voteLast(algoTxn.voteLast);\n        this.voteKeyDilution(algoTxn.voteKeyDilution);\n        if (algoTxn.stateProofKey) {\n          this.stateProofKey(algoTxn.stateProofKey.toString('base64'));\n        }\n      }\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: Uint8Array | string): void {\n    const decodeTxn = Utils.decodeAlgoTxn(rawTransaction);\n    const algoTxn = decodeTxn.txn;\n    if (algoTxn.type !== algosdk.TransactionType.keyreg) {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${algoTxn.type}. Expected ${algosdk.TransactionType.keyreg}`\n      );\n    }\n\n    if (this.isOnlineKeyRegAlgoSDKTransaction(algoTxn)) {\n      this.validateFields(\n        algoTxn.voteKey.toString('base64'),\n        algoTxn.selectionKey.toString('base64'),\n        algoTxn.voteFirst,\n        algoTxn.voteLast,\n        algoTxn.voteKeyDilution,\n        algoTxn.stateProofKey && algoTxn.stateProofKey.toString('base64')\n      );\n    }\n  }\n\n  private isNonParticipationKeyRegAlgoSDKTransaction(algoTxn: algosdk.Transaction): boolean {\n    return !!algoTxn.nonParticipation;\n  }\n\n  private isNonParticipationKeyRegAccountLibTransaction(): boolean {\n    return !!this._nonParticipation;\n  }\n\n  private isOnlineKeyRegAlgoSDKTransaction(algoTxn: algosdk.Transaction): boolean {\n    return !(\n      this.isOfflineKeyRegAlgoSDKTransaction(algoTxn) || this.isNonParticipationKeyRegAlgoSDKTransaction(algoTxn)\n    );\n  }\n\n  private isOnlineKeyRegAccountLibTransaction(): boolean {\n    return !(this.isOfflineKeyRegAccountLibTransaction() || this.isNonParticipationKeyRegAccountLibTransaction());\n  }\n\n  private isOfflineKeyRegAlgoSDKTransaction(algoTxn: algosdk.Transaction): boolean {\n    return (\n      !algoTxn.voteKey &&\n      !algoTxn.selectionKey &&\n      !algoTxn.voteFirst &&\n      !algoTxn.voteLast &&\n      !algoTxn.voteKeyDilution &&\n      !algoTxn.stateProofKey &&\n      !algoTxn.nonParticipation\n    );\n  }\n\n  private isOfflineKeyRegAccountLibTransaction(): boolean {\n    return (\n      !this._voteKey &&\n      !this._selectionKey &&\n      !this._voteFirst &&\n      !this._voteLast &&\n      !this._voteKeyDilution &&\n      !this._stateProofKey &&\n      !this._nonParticipation\n    );\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: Transaction): void {\n    super.validateTransaction(transaction);\n    if (this.isOnlineKeyRegAccountLibTransaction()) {\n      // invalid offline will reach here\n      this.validateFields(\n        this._voteKey,\n        this._selectionKey,\n        this._voteFirst,\n        this._voteLast,\n        this._voteKeyDilution,\n        this._stateProofKey\n      );\n    } else {\n      // offline or nonparticipation transaction\n      if (\n        this._voteKey ||\n        this._selectionKey ||\n        this._voteFirst ||\n        this._voteLast ||\n        this._voteKeyDilution ||\n        this._stateProofKey\n      ) {\n        throw new InvalidTransactionError(\n          'VoteKey, SelectionKey, VoteFirst, VoteLast, VoteKeyDilution, StateProofKey fields cannot be set when offline or nonparticipation is set'\n        );\n      }\n    }\n  }\n\n  private validateFields(\n    voteKey: string,\n    selectionKey: string,\n    voteFirst: number,\n    voteLast: number,\n    voteKeyDilution: number,\n    stateProofKey?: string\n  ): void {\n    const validationResult = KeyRegTxnSchema.validate({\n      voteKey,\n      selectionKey,\n      voteFirst,\n      voteLast,\n      voteKeyDilution,\n      stateProofKey,\n    });\n\n    if (validationResult.error) {\n      throw new InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,25 @@
+import { Seed } from './ifaces';
+export declare class SeedEncoding {
+    private static genericHash;
+    /**
+     * Checks if a seed is valid
+     * @param {String} seed - encoded Algorand seed
+     * @returns {Boolean} true if valid, false otherwise
+     */
+    static isValidSeed(seed: string): boolean;
+    /**
+     * Decode a seed
+     *
+     * @param seed
+     * @return {{checksum: Uint8Array, seed: Uint8Array}}
+     */
+    static decode(seed: string): Seed;
+    /**
+     * Encode a secret key into a seed
+     *
+     * @param secretKey
+     * @return {String} encoded seed
+     */
+    static encode(secretKey: Uint8Array): string;
+}
+//# sourceMappingURL=seedEncoding.d.ts.map

package/dist/src/lib/seedEncoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seedEncoding.d.ts","sourceRoot":"","sources":["../../../src/lib/seedEncoding.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAOhC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IA0BzC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAajC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;CAe7C"}

package/dist/src/lib/seedEncoding.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedEncoding = void 0;
+const base32 = __importStar(require("hi-base32"));
+const js_sha512_1 = __importDefault(require("js-sha512"));
+const SEED_BYTES_LENGTH = 32;
+const ALGORAND_SEED_BYTE_LENGTH = 36;
+const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
+const ALGORAND_SEED_LENGTH = 58;
+class SeedEncoding {
+    static genericHash(arr) {
+        return js_sha512_1.default.sha512_256.array(arr);
+    }
+    /**
+     * Checks if a seed is valid
+     * @param {String} seed - encoded Algorand seed
+     * @returns {Boolean} true if valid, false otherwise
+     */
+    static isValidSeed(seed) {
+        if (seed.length !== ALGORAND_SEED_LENGTH) {
+            return false;
+        }
+        // Try to decode
+        let decoded;
+        try {
+            decoded = SeedEncoding.decode(seed);
+        }
+        catch (e) {
+            return false;
+        }
+        // Compute checksum
+        const checksum = SeedEncoding.genericHash(decoded.seed).slice(SEED_BYTES_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, SEED_BYTES_LENGTH);
+        // Check if the checksum and the seed are equal
+        if (checksum.length !== decoded.checksum.length) {
+            return false;
+        }
+        return checksum.every((val, i) => val === decoded.checksum[i]);
+    }
+    /**
+     * Decode a seed
+     *
+     * @param seed
+     * @return {{checksum: Uint8Array, seed: Uint8Array}}
+     */
+    static decode(seed) {
+        // try to decode
+        const decoded = base32.decode.asBytes(seed);
+        // Sanity check
+        if (decoded.length !== ALGORAND_SEED_BYTE_LENGTH)
+            throw new Error('seed seems to be malformed');
+        return {
+            seed: new Uint8Array(decoded.slice(0, ALGORAND_SEED_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH)),
+            checksum: new Uint8Array(decoded.slice(SEED_BYTES_LENGTH, ALGORAND_SEED_BYTE_LENGTH)),
+        };
+    }
+    /**
+     * Encode a secret key into a seed
+     *
+     * @param secretKey
+     * @return {String} encoded seed
+     */
+    static encode(secretKey) {
+        // get seed
+        const seed = secretKey.slice(0, SEED_BYTES_LENGTH);
+        // compute checksum
+        const checksum = SeedEncoding.genericHash(seed).slice(SEED_BYTES_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, SEED_BYTES_LENGTH);
+        const arraySeed = new Uint8Array(seed.length + checksum.length);
+        arraySeed.set(seed);
+        arraySeed.set(checksum, seed.length);
+        const encodedSeed = base32.encode(arraySeed);
+        return encodedSeed.toString().slice(0, ALGORAND_SEED_LENGTH); // removing the extra '===='
+    }
+}
+exports.SeedEncoding = SeedEncoding;
+//# sourceMappingURL=data:application/json;base64,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