@bitgo/account-lib 2.17.2-rc.0.1 → 2.17.2-rc.4

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

@@ -0,0 +1,140 @@
+"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;
+        if (!address || !utils_1.isValidPublicKey(address)) {
+            throw new errors_1.BuildTransactionError('Invalid or missing address, got: ' + 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,104 @@
+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 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;
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Only Wallet initialization and Transfer 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;
+//# 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,EAGnB,WAAW,IAAI,cAAc,EAC7B,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAUzB,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,CAWxD;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,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,kBAAkB,CAAC,WAAW,EAAE,cAAc,GAAG,eAAe,CAa/E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,sBAAsB,GAAG,qBAAqB,CAW7F;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"}

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

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRawTransaction = exports.validateIntructionTypes = exports.getInstructionType = exports.getTransactionType = exports.requiresAllSignatures = exports.countNotNullSignatures = exports.Uint8ArrayTobase58 = exports.base58ToUint8Array = exports.verifySignature = exports.isValidRawTransaction = exports.isValidMemo = 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 DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format
+var DECODED_ADDRESS_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#account-address-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 {
+        return (!!pubKey &&
+            new RegExp(BASE_58_ENCONDING_REGEX).test(pubKey) &&
+            bs58_1.default.decode(pubKey).length === DECODED_ADDRESS_LENGTH &&
+            web3_js_1.PublicKey.isOnCurve(new web3_js_1.PublicKey(pubKey).toBuffer()));
+    }
+    catch (e) {
+        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 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;
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Only Wallet initialization and Transfer 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 (instructions.length <= 3 &&
+        getInstructionType(instructions[constants_1.walletInitInstructionIndexes.Create]) === constants_1.ValidInstructionTypesEnum.Create &&
+        getInstructionType(instructions[constants_1.walletInitInstructionIndexes.InitializeNonce]) ===
+            constants_1.ValidInstructionTypesEnum.InitializeNonceAccount) {
+        return baseCoin_1.TransactionType.WalletInitialization;
+    }
+    else {
+        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);
+        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;
+//# 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  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  ValidInstructionTypesEnum,\n  VALID_SYSTEM_INSTRUCTION_TYPES,\n  walletInitInstructionIndexes,\n} from './constants';\nimport { TransactionType } from '../baseCoin';\nimport { NotSupported, ParseTransactionError, UtilsError } from '../baseCoin/errors';\nimport { ValidInstructionTypes } from './iface';\nimport nacl from 'tweetnacl';\n\nconst DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format\nconst DECODED_ADDRESS_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#account-address-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    return (\n      !!pubKey &&\n      new RegExp(BASE_58_ENCONDING_REGEX).test(pubKey) &&\n      bs58.decode(pubKey).length === DECODED_ADDRESS_LENGTH &&\n      PublicKey.isOnCurve(new PublicKey(pubKey).toBuffer())\n    );\n  } catch (e) {\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 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 * Returns the transaction Type based on the  transaction instructions.\n * Only Wallet initialization and Transfer 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 (\n    instructions.length <= 3 &&\n    getInstructionType(instructions[walletInitInstructionIndexes.Create]) === ValidInstructionTypesEnum.Create &&\n    getInstructionType(instructions[walletInitInstructionIndexes.InitializeNonce]) ===\n      ValidInstructionTypesEnum.InitializeNonceAccount\n  ) {\n    return TransactionType.WalletInitialization;\n  } else {\n    return TransactionType.Send;\n  }\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    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"]}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"walletInitializationBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/walletInitializationBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAI9C,qBAAa,2BAA4B,SAAQ,kBAAkB;IACjE,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAS;gBAEZ,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAG7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAclC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAS5B;;;OAGG;IACH,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAUnC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAkB5D"}