@bitgo/account-lib 2.17.1-rc.8 → 2.17.2-node12.0

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

@@ -0,0 +1,138 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+var errors_1 = require("../baseCoin/errors");
+var transactionBuilder_1 = require("./transactionBuilder");
+var utils_1 = require("./utils");
+var baseCoin_1 = require("../baseCoin");
+var constants_1 = require("./constants");
+var assert_1 = __importDefault(require("assert"));
+var TransferBuilder = /** @class */ (function (_super) {
+    __extends(TransferBuilder, _super);
+    function TransferBuilder(_coinConfig) {
+        var _this = _super.call(this, _coinConfig) || this;
+        _this._sendParams = [];
+        return _this;
+    }
+    Object.defineProperty(TransferBuilder.prototype, "transactionType", {
+        get: function () {
+            return baseCoin_1.TransactionType.Send;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TransferBuilder.prototype.initBuilder = function (tx) {
+        _super.prototype.initBuilder.call(this, tx);
+        for (var _i = 0, _a = this._instructionsData; _i < _a.length; _i++) {
+            var instruction = _a[_i];
+            if (instruction.type === constants_1.InstructionBuilderTypes.Transfer) {
+                var transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                });
+            }
+        }
+    };
+    /**
+     *  Set a transfer
+     *
+     * @param {string} fromAddress - the sender address
+     * @param {string} toAddress - the receiver address
+     * @param {string} amount - the amount sent
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    TransferBuilder.prototype.send = function (_a) {
+        var address = _a.address, amount = _a.amount;
+        utils_1.validateAddress(address, 'address');
+        if (!amount || !utils_1.isValidAmount(amount)) {
+            throw new errors_1.BuildTransactionError('Invalid or missing amount, got: ' + amount);
+        }
+        this._sendParams.push({ address: address, amount: amount });
+        return this;
+    };
+    /** @inheritdoc */
+    TransferBuilder.prototype.buildImplementation = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferData;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        assert_1.default(this._sender, 'Sender must be set before building the transaction');
+                        transferData = this._sendParams.map(function (sendParams) {
+                            return {
+                                type: constants_1.InstructionBuilderTypes.Transfer,
+                                params: {
+                                    fromAddress: _this._sender,
+                                    toAddress: sendParams.address,
+                                    amount: sendParams.amount,
+                                },
+                            };
+                        });
+                        this._instructionsData = transferData;
+                        return [4 /*yield*/, _super.prototype.buildImplementation.call(this)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return TransferBuilder;
+}(transactionBuilder_1.TransactionBuilder));
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,126 @@
+import { SignaturePubkeyPair, Transaction as SolTransaction, TransactionInstruction } from '@solana/web3.js';
+import { TransactionType } from '../baseCoin';
+import { ValidInstructionTypes } from './iface';
+/** @inheritdoc */
+export declare function isValidAddress(address: string): boolean;
+/** @inheritdoc */
+export declare function isValidBlockId(hash: string): boolean;
+/** @inheritdoc */
+export declare function isValidPrivateKey(prvKey: string | Uint8Array): boolean;
+/** @inheritdoc */
+export declare function isValidPublicKey(pubKey: string): boolean;
+/** @inheritdoc */
+export declare function isValidSignature(signature: string): boolean;
+/** @inheritdoc */
+export declare function isValidTransactionId(txId: string): boolean;
+/**
+ * Returns whether or not the string is a valid amount of lamports number
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidAmount(amount: string): boolean;
+/**
+ * Check if the string is a valid amount of lamports number on staking
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidStakingAmount(amount: string): boolean;
+/**
+ * Check if this is a valid memo or not.
+ *
+ * @param memo - the memo string
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidMemo(memo: string): boolean;
+/**
+ * Checks if raw transaction can be deserialized
+ *
+ * @param {string} rawTransaction - transaction in base64 string format
+ * @returns {boolean} - the validation result
+ */
+export declare function isValidRawTransaction(rawTransaction: string): boolean;
+/**
+ * Verifies if signature for message is valid.
+ *
+ * @param {Buffer} serializedTx - tx as a base64 string
+ * @param {string} signature - signature as a string
+ * @param {string} publicKey - public key as base 58
+ * @returns {Boolean} true if signature is valid.
+ */
+export declare function verifySignature(serializedTx: string, signature: string, publicKey: string): boolean;
+/**
+ * Converts a base58 string into a Uint8Array.
+ *
+ * @param {string} input - a string in base58
+ * @returns {Uint8Array} - an Uint8Array
+ */
+export declare function base58ToUint8Array(input: string): Uint8Array;
+/**
+ * Converts a Uint8Array to a base58 string.
+ *
+ * @param {Uint8Array} input - an Uint8Array
+ * @returns {string} - a string in base58
+ */
+export declare function Uint8ArrayTobase58(input: Uint8Array): string;
+/**
+ * Count the amount of signatures are not null.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair
+ * @returns {number} - the amount of valid signatures
+ */
+export declare function countNotNullSignatures(signatures: SignaturePubkeyPair[]): number;
+/**
+ * Check if all signatures are completed.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - signatures
+ * @returns {boolean}
+ */
+export declare function requiresAllSignatures(signatures: SignaturePubkeyPair[]): boolean;
+/**
+ * Check the transaction type matching instructions by order.
+ *
+ * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed
+ * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction
+ * @returns true if it matchs by order.
+ */
+export declare function matchTransactionTypeByInstructionsOrder(instructions: TransactionInstruction[], instructionIndexes: Record<string, number>): boolean;
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Wallet initialization, Transfer and Staking transactions are supported.
+ *
+ * @param {SolTransaction} transaction - the solana transaction
+ * @returns {TransactionType} - the type of transaction
+ */
+export declare function getTransactionType(transaction: SolTransaction): TransactionType;
+/**
+ * Returns the a instruction Type based on the solana instructions.
+ * Throws if the solana instruction program is not supported
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {ValidInstructionTypes} - a  solana instruction type
+ */
+export declare function getInstructionType(instruction: TransactionInstruction): ValidInstructionTypes;
+/**
+ * Validate solana instructions types to see if they are supported by the builder.
+ * Throws if the instruction type is invalid.
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {void}
+ */
+export declare function validateIntructionTypes(instructions: TransactionInstruction[]): void;
+/**
+ * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+ *
+ * @param {string} rawTransaction - Transaction in base64 string  format
+ */
+export declare function validateRawTransaction(rawTransaction: string): void;
+/**
+ * Validates address to check if it exists and is a valid Solana public key
+ *
+ * @param {string} address The address to be validated
+ * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.
+ */
+export declare function validateAddress(address: string, fieldName: string): void;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,mBAAmB,EAKnB,WAAW,IAAI,cAAc,EAC7B,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAYzB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAQhD,kBAAkB;AAClB,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,kBAAkB;AAClB,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQpD;AAED,kBAAkB;AAClB,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAOtE;AAED,kBAAkB;AAClB,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQxD;AAED,kBAAkB;AAClB,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED,kBAAkB;AAElB,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAQrE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAcnG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CACrD,YAAY,EAAE,sBAAsB,EAAE,EACtC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,OAAO,CAeT;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,cAAc,GAAG,eAAe,CAa/E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,sBAAsB,GAAG,qBAAqB,CAa7F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,sBAAsB,EAAE,GAAG,IAAI,CAMpF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAOnE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAIxE"}

package/dist/src/coin/sol/utils.js

@@ -0,0 +1,315 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.validateAddress = exports.validateRawTransaction = exports.validateIntructionTypes = exports.getInstructionType = exports.getTransactionType = exports.matchTransactionTypeByInstructionsOrder = exports.requiresAllSignatures = exports.countNotNullSignatures = exports.Uint8ArrayTobase58 = exports.base58ToUint8Array = exports.verifySignature = exports.isValidRawTransaction = exports.isValidMemo = exports.isValidStakingAmount = exports.isValidAmount = exports.isValidTransactionId = exports.isValidSignature = exports.isValidPublicKey = exports.isValidPrivateKey = exports.isValidBlockId = exports.isValidAddress = void 0;
+var web3_js_1 = require("@solana/web3.js");
+var bs58_1 = __importDefault(require("bs58"));
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var constants_1 = require("./constants");
+var baseCoin_1 = require("../baseCoin");
+var errors_1 = require("../baseCoin/errors");
+var tweetnacl_1 = __importDefault(require("tweetnacl"));
+var Crypto = __importStar(require("./../../utils/crypto"));
+var DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format
+var DECODED_SIGNATURE_LENGTH = 64; // https://docs.solana.com/terminology#signature
+var BASE_58_ENCONDING_REGEX = '[1-9A-HJ-NP-Za-km-z]';
+/** @inheritdoc */
+function isValidAddress(address) {
+    return isValidPublicKey(address);
+}
+exports.isValidAddress = isValidAddress;
+/** @inheritdoc */
+function isValidBlockId(hash) {
+    try {
+        return (!!hash && new RegExp(BASE_58_ENCONDING_REGEX).test(hash) && bs58_1.default.decode(hash).length === DECODED_BLOCK_HASH_LENGTH);
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidBlockId = isValidBlockId;
+/** @inheritdoc */
+function isValidPrivateKey(prvKey) {
+    try {
+        var key = typeof prvKey === 'string' ? this.base58ToUint8Array(prvKey) : prvKey;
+        return !!web3_js_1.Keypair.fromSecretKey(key);
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidPrivateKey = isValidPrivateKey;
+/** @inheritdoc */
+function isValidPublicKey(pubKey) {
+    try {
+        if (Crypto.isValidXpub(pubKey))
+            return true;
+        new web3_js_1.PublicKey(pubKey);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.isValidPublicKey = isValidPublicKey;
+/** @inheritdoc */
+function isValidSignature(signature) {
+    try {
+        return !!signature && bs58_1.default.decode(signature).length === DECODED_SIGNATURE_LENGTH;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidSignature = isValidSignature;
+/** @inheritdoc */
+// TransactionId are the first signature on a Transaction
+function isValidTransactionId(txId) {
+    return this.isValidSignature(txId);
+}
+exports.isValidTransactionId = isValidTransactionId;
+/**
+ * Returns whether or not the string is a valid amount of lamports number
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidAmount(amount) {
+    var bigNumberAmount = new bignumber_js_1.default(amount);
+    return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);
+}
+exports.isValidAmount = isValidAmount;
+/**
+ * Check if the string is a valid amount of lamports number on staking
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidStakingAmount(amount) {
+    var bigNumberAmount = new bignumber_js_1.default(amount);
+    return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThan(0);
+}
+exports.isValidStakingAmount = isValidStakingAmount;
+/**
+ * Check if this is a valid memo or not.
+ *
+ * @param memo - the memo string
+ * @returns {boolean} - the validation result
+ */
+function isValidMemo(memo) {
+    return Buffer.from(memo).length <= constants_1.MAX_MEMO_LENGTH;
+}
+exports.isValidMemo = isValidMemo;
+/**
+ * Checks if raw transaction can be deserialized
+ *
+ * @param {string} rawTransaction - transaction in base64 string format
+ * @returns {boolean} - the validation result
+ */
+function isValidRawTransaction(rawTransaction) {
+    try {
+        var tx = web3_js_1.Transaction.from(Buffer.from(rawTransaction, 'base64'));
+        tx.serialize({ requireAllSignatures: false });
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidRawTransaction = isValidRawTransaction;
+/**
+ * Verifies if signature for message is valid.
+ *
+ * @param {Buffer} serializedTx - tx as a base64 string
+ * @param {string} signature - signature as a string
+ * @param {string} publicKey - public key as base 58
+ * @returns {Boolean} true if signature is valid.
+ */
+function verifySignature(serializedTx, signature, publicKey) {
+    if (!isValidRawTransaction(serializedTx)) {
+        throw new errors_1.UtilsError('Invalid serializedTx');
+    }
+    if (!isValidPublicKey(publicKey)) {
+        throw new errors_1.UtilsError('Invalid publicKey');
+    }
+    if (!isValidSignature(signature)) {
+        throw new errors_1.UtilsError('Invalid signature');
+    }
+    var msg = web3_js_1.Transaction.from(Buffer.from(serializedTx, 'base64')).serializeMessage();
+    var sig = base58ToUint8Array(signature);
+    var pub = new web3_js_1.PublicKey(publicKey);
+    return tweetnacl_1.default.sign.detached.verify(msg, sig, pub.toBuffer());
+}
+exports.verifySignature = verifySignature;
+/**
+ * Converts a base58 string into a Uint8Array.
+ *
+ * @param {string} input - a string in base58
+ * @returns {Uint8Array} - an Uint8Array
+ */
+function base58ToUint8Array(input) {
+    return new Uint8Array(bs58_1.default.decode(input));
+}
+exports.base58ToUint8Array = base58ToUint8Array;
+/**
+ * Converts a Uint8Array to a base58 string.
+ *
+ * @param {Uint8Array} input - an Uint8Array
+ * @returns {string} - a string in base58
+ */
+function Uint8ArrayTobase58(input) {
+    return bs58_1.default.encode(input);
+}
+exports.Uint8ArrayTobase58 = Uint8ArrayTobase58;
+/**
+ * Count the amount of signatures are not null.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair
+ * @returns {number} - the amount of valid signatures
+ */
+function countNotNullSignatures(signatures) {
+    return signatures.filter(function (sig) { return !!sig.signature; }).length;
+}
+exports.countNotNullSignatures = countNotNullSignatures;
+/**
+ * Check if all signatures are completed.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - signatures
+ * @returns {boolean}
+ */
+function requiresAllSignatures(signatures) {
+    return signatures.length > 0 && countNotNullSignatures(signatures) === signatures.length;
+}
+exports.requiresAllSignatures = requiresAllSignatures;
+/**
+ * Check the transaction type matching instructions by order.
+ *
+ * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed
+ * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction
+ * @returns true if it matchs by order.
+ */
+function matchTransactionTypeByInstructionsOrder(instructions, instructionIndexes) {
+    var instructionsKeys = Object.keys(instructionIndexes);
+    // Memo is optional and the last instruction added, it does not matter to match the type
+    if (instructionsKeys[instructionsKeys.length - 1] === 'Memo') {
+        instructionsKeys.pop();
+    }
+    // Check instructions by order using the index.
+    for (var _i = 0, instructionsKeys_1 = instructionsKeys; _i < instructionsKeys_1.length; _i++) {
+        var keyName = instructionsKeys_1[_i];
+        if (getInstructionType(instructions[instructionIndexes[keyName]]) !== keyName) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.matchTransactionTypeByInstructionsOrder = matchTransactionTypeByInstructionsOrder;
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Wallet initialization, Transfer and Staking transactions are supported.
+ *
+ * @param {SolTransaction} transaction - the solana transaction
+ * @returns {TransactionType} - the type of transaction
+ */
+function getTransactionType(transaction) {
+    var instructions = transaction.instructions;
+    validateIntructionTypes(instructions);
+    if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.walletInitInstructionIndexes)) {
+        return baseCoin_1.TransactionType.WalletInitialization;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingActivateInstructionsIndexes)) {
+        return baseCoin_1.TransactionType.StakingActivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingDeactivateInstructionsIndexes)) {
+        return baseCoin_1.TransactionType.StakingDeactivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingWithdrawInstructionsIndexes)) {
+        return baseCoin_1.TransactionType.StakingWithdraw;
+    }
+    return baseCoin_1.TransactionType.Send;
+}
+exports.getTransactionType = getTransactionType;
+/**
+ * Returns the a instruction Type based on the solana instructions.
+ * Throws if the solana instruction program is not supported
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {ValidInstructionTypes} - a  solana instruction type
+ */
+function getInstructionType(instruction) {
+    switch (instruction.programId.toString()) {
+        case new web3_js_1.PublicKey(constants_1.MEMO_PROGRAM_PK).toString():
+            return 'Memo';
+        case web3_js_1.SystemProgram.programId.toString():
+            return web3_js_1.SystemInstruction.decodeInstructionType(instruction);
+        case web3_js_1.StakeProgram.programId.toString():
+            return web3_js_1.StakeInstruction.decodeInstructionType(instruction);
+        default:
+            throw new errors_1.NotSupported('Invalid transaction, instruction program id not supported: ' + instruction.programId.toString());
+    }
+}
+exports.getInstructionType = getInstructionType;
+/**
+ * Validate solana instructions types to see if they are supported by the builder.
+ * Throws if the instruction type is invalid.
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {void}
+ */
+function validateIntructionTypes(instructions) {
+    for (var _i = 0, instructions_1 = instructions; _i < instructions_1.length; _i++) {
+        var instruction = instructions_1[_i];
+        if (!constants_1.VALID_SYSTEM_INSTRUCTION_TYPES.includes(getInstructionType(instruction))) {
+            throw new errors_1.NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+        }
+    }
+}
+exports.validateIntructionTypes = validateIntructionTypes;
+/**
+ * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+ *
+ * @param {string} rawTransaction - Transaction in base64 string  format
+ */
+function validateRawTransaction(rawTransaction) {
+    if (!rawTransaction) {
+        throw new errors_1.ParseTransactionError('Invalid raw transaction: Undefined');
+    }
+    if (!isValidRawTransaction(rawTransaction)) {
+        throw new errors_1.ParseTransactionError('Invalid raw transaction');
+    }
+}
+exports.validateRawTransaction = validateRawTransaction;
+/**
+ * Validates address to check if it exists and is a valid Solana public key
+ *
+ * @param {string} address The address to be validated
+ * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.
+ */
+function validateAddress(address, fieldName) {
+    if (!address || !isValidPublicKey(address)) {
+        throw new errors_1.BuildTransactionError("Invalid or missing " + fieldName + ", got: " + address);
+    }
+}
+exports.validateAddress = validateAddress;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/coin/sol/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Keypair,\n  PublicKey,\n  SignaturePubkeyPair,\n  StakeInstruction,\n  StakeProgram,\n  SystemInstruction,\n  SystemProgram,\n  Transaction as SolTransaction,\n  TransactionInstruction,\n} from '@solana/web3.js';\nimport bs58 from 'bs58';\nimport BigNumber from 'bignumber.js';\nimport {\n  MAX_MEMO_LENGTH,\n  MEMO_PROGRAM_PK,\n  stakingActivateInstructionsIndexes,\n  stakingDeactivateInstructionsIndexes,\n  stakingWithdrawInstructionsIndexes,\n  VALID_SYSTEM_INSTRUCTION_TYPES,\n  walletInitInstructionIndexes,\n} from './constants';\nimport { TransactionType } from '../baseCoin';\nimport { NotSupported, ParseTransactionError, UtilsError, BuildTransactionError } from '../baseCoin/errors';\nimport { ValidInstructionTypes } from './iface';\nimport nacl from 'tweetnacl';\nimport * as Crypto from './../../utils/crypto';\n\nconst DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format\nconst DECODED_SIGNATURE_LENGTH = 64; // https://docs.solana.com/terminology#signature\nconst BASE_58_ENCONDING_REGEX = '[1-9A-HJ-NP-Za-km-z]';\n\n/** @inheritdoc */\nexport function isValidAddress(address: string): boolean {\n  return isValidPublicKey(address);\n}\n\n/** @inheritdoc */\nexport function isValidBlockId(hash: string): boolean {\n  try {\n    return (\n      !!hash && new RegExp(BASE_58_ENCONDING_REGEX).test(hash) && bs58.decode(hash).length === DECODED_BLOCK_HASH_LENGTH\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidPrivateKey(prvKey: string | Uint8Array): boolean {\n  try {\n    const key: Uint8Array = typeof prvKey === 'string' ? this.base58ToUint8Array(prvKey) : prvKey;\n    return !!Keypair.fromSecretKey(key);\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidPublicKey(pubKey: string): boolean {\n  try {\n    if (Crypto.isValidXpub(pubKey)) return true;\n    new PublicKey(pubKey);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidSignature(signature: string): boolean {\n  try {\n    return !!signature && bs58.decode(signature).length === DECODED_SIGNATURE_LENGTH;\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\n// TransactionId are the first signature on a Transaction\nexport function isValidTransactionId(txId: string): boolean {\n  return this.isValidSignature(txId);\n}\n\n/**\n * Returns whether or not the string is a valid amount of lamports number\n *\n * @param {string} amount - the string to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidAmount(amount: string): boolean {\n  const bigNumberAmount = new BigNumber(amount);\n  return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);\n}\n\n/**\n * Check if the string is a valid amount of lamports number on staking\n *\n * @param {string} amount - the string to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidStakingAmount(amount: string): boolean {\n  const bigNumberAmount = new BigNumber(amount);\n  return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThan(0);\n}\n\n/**\n * Check if this is a valid memo or not.\n *\n * @param memo - the memo string\n * @returns {boolean} - the validation result\n */\nexport function isValidMemo(memo: string): boolean {\n  return Buffer.from(memo).length <= MAX_MEMO_LENGTH;\n}\n\n/**\n * Checks if raw transaction can be deserialized\n *\n * @param {string} rawTransaction - transaction in base64 string format\n * @returns {boolean} - the validation result\n */\nexport function isValidRawTransaction(rawTransaction: string): boolean {\n  try {\n    const tx = SolTransaction.from(Buffer.from(rawTransaction, 'base64'));\n    tx.serialize({ requireAllSignatures: false });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Verifies if signature for message is valid.\n *\n * @param {Buffer} serializedTx - tx as a base64 string\n * @param {string} signature - signature as a string\n * @param {string} publicKey - public key as base 58\n * @returns {Boolean} true if signature is valid.\n */\nexport function verifySignature(serializedTx: string, signature: string, publicKey: string): boolean {\n  if (!isValidRawTransaction(serializedTx)) {\n    throw new UtilsError('Invalid serializedTx');\n  }\n  if (!isValidPublicKey(publicKey)) {\n    throw new UtilsError('Invalid publicKey');\n  }\n  if (!isValidSignature(signature)) {\n    throw new UtilsError('Invalid signature');\n  }\n  const msg = SolTransaction.from(Buffer.from(serializedTx, 'base64')).serializeMessage();\n  const sig = base58ToUint8Array(signature);\n  const pub = new PublicKey(publicKey);\n  return nacl.sign.detached.verify(msg, sig, pub.toBuffer());\n}\n\n/**\n * Converts a base58 string into a Uint8Array.\n *\n * @param {string} input - a string in base58\n * @returns {Uint8Array} - an Uint8Array\n */\nexport function base58ToUint8Array(input: string): Uint8Array {\n  return new Uint8Array(bs58.decode(input));\n}\n\n/**\n * Converts a Uint8Array to a base58 string.\n *\n * @param {Uint8Array} input - an Uint8Array\n * @returns {string} - a string in base58\n */\nexport function Uint8ArrayTobase58(input: Uint8Array): string {\n  return bs58.encode(input);\n}\n\n/**\n * Count the amount of signatures are not null.\n *\n * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair\n * @returns {number} - the amount of valid signatures\n */\nexport function countNotNullSignatures(signatures: SignaturePubkeyPair[]): number {\n  return signatures.filter((sig) => !!sig.signature).length;\n}\n\n/**\n * Check if all signatures are completed.\n *\n * @param {SignaturePubkeyPair[]} signatures - signatures\n * @returns {boolean}\n */\nexport function requiresAllSignatures(signatures: SignaturePubkeyPair[]): boolean {\n  return signatures.length > 0 && countNotNullSignatures(signatures) === signatures.length;\n}\n\n/**\n * Check the transaction type matching instructions by order.\n *\n * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed\n * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction\n * @returns true if it matchs by order.\n */\nexport function matchTransactionTypeByInstructionsOrder(\n  instructions: TransactionInstruction[],\n  instructionIndexes: Record<string, number>,\n): boolean {\n  const instructionsKeys = Object.keys(instructionIndexes);\n\n  // Memo is optional and the last instruction added, it does not matter to match the type\n  if (instructionsKeys[instructionsKeys.length - 1] === 'Memo') {\n    instructionsKeys.pop();\n  }\n\n  // Check instructions by order using the index.\n  for (const keyName of instructionsKeys) {\n    if (getInstructionType(instructions[instructionIndexes[keyName]]) !== keyName) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns the transaction Type based on the  transaction instructions.\n * Wallet initialization, Transfer and Staking transactions are supported.\n *\n * @param {SolTransaction} transaction - the solana transaction\n * @returns {TransactionType} - the type of transaction\n */\nexport function getTransactionType(transaction: SolTransaction): TransactionType {\n  const { instructions } = transaction;\n  validateIntructionTypes(instructions);\n  if (matchTransactionTypeByInstructionsOrder(instructions, walletInitInstructionIndexes)) {\n    return TransactionType.WalletInitialization;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingActivateInstructionsIndexes)) {\n    return TransactionType.StakingActivate;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingDeactivateInstructionsIndexes)) {\n    return TransactionType.StakingDeactivate;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingWithdrawInstructionsIndexes)) {\n    return TransactionType.StakingWithdraw;\n  }\n  return TransactionType.Send;\n}\n\n/**\n * Returns the a instruction Type based on the solana instructions.\n * Throws if the solana instruction program is not supported\n *\n * @param {TransactionInstruction} instruction - a solana instruction\n * @returns {ValidInstructionTypes} - a  solana instruction type\n */\nexport function getInstructionType(instruction: TransactionInstruction): ValidInstructionTypes {\n  switch (instruction.programId.toString()) {\n    case new PublicKey(MEMO_PROGRAM_PK).toString():\n      return 'Memo';\n    case SystemProgram.programId.toString():\n      return SystemInstruction.decodeInstructionType(instruction);\n    case StakeProgram.programId.toString():\n      return StakeInstruction.decodeInstructionType(instruction);\n    default:\n      throw new NotSupported(\n        'Invalid transaction, instruction program id not supported: ' + instruction.programId.toString(),\n      );\n  }\n}\n\n/**\n * Validate solana instructions types to see if they are supported by the builder.\n * Throws if the instruction type is invalid.\n *\n * @param {TransactionInstruction} instruction - a solana instruction\n * @returns {void}\n */\nexport function validateIntructionTypes(instructions: TransactionInstruction[]): void {\n  for (const instruction of instructions) {\n    if (!VALID_SYSTEM_INSTRUCTION_TYPES.includes(getInstructionType(instruction))) {\n      throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));\n    }\n  }\n}\n\n/**\n * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n *\n * @param {string} rawTransaction - Transaction in base64 string  format\n */\nexport function validateRawTransaction(rawTransaction: string): void {\n  if (!rawTransaction) {\n    throw new ParseTransactionError('Invalid raw transaction: Undefined');\n  }\n  if (!isValidRawTransaction(rawTransaction)) {\n    throw new ParseTransactionError('Invalid raw transaction');\n  }\n}\n\n/**\n * Validates address to check if it exists and is a valid Solana public key\n *\n * @param {string} address The address to be validated\n * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n */\nexport function validateAddress(address: string, fieldName: string): void {\n  if (!address || !isValidPublicKey(address)) {\n    throw new BuildTransactionError(`Invalid or missing ${fieldName}, got: ${address}`);\n  }\n}\n"]}

package/dist/src/coin/sol/walletInitializationBuilder.d.ts

@@ -0,0 +1,26 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { TransactionType } from '../baseCoin';
+export declare class WalletInitializationBuilder extends TransactionBuilder {
+    private _nonceAddress;
+    private _amount;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritDoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Sets the amount to fund the nonce account
+     *
+     * @param amount amount in lamports to fund the nonce account
+     */
+    amount(amount: string): this;
+    /**
+     * Sets the address for the nonce account
+     * @param nonceAddress address of the new nonce account
+     */
+    address(nonceAddress: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=walletInitializationBuilder.d.ts.map