@bitgo/account-lib 2.17.2-2.17.2-rc.0.0 → 2.17.2-rc.2

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

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyPair = void 0;
+var web3_js_1 = require("@solana/web3.js");
+var tweetnacl_1 = __importDefault(require("tweetnacl"));
+var errors_1 = require("../baseCoin/errors");
+var iface_1 = require("../baseCoin/iface");
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+// The Solana Key Pair is an ED25519 but the current ED25519 implementation doesnt return base58 strings
+// TODO(): Refactor to ED25519 Keypair instead of BaseKeyPair
+var KeyPair = /** @class */ (function () {
+    /**
+     * 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
+     */
+    function KeyPair(source) {
+        var kp;
+        if (!source) {
+            kp = web3_js_1.Keypair.generate();
+            this.setKP(kp);
+        }
+        else if (iface_1.isSeed(source)) {
+            kp = web3_js_1.Keypair.fromSeed(source.seed.slice(0, constants_1.SEED_LENGTH));
+            this.setKP(kp);
+        }
+        else if (iface_1.isPrivateKey(source)) {
+            this.recordKeysFromPrivateKey(source.prv);
+        }
+        else if (iface_1.isPublicKey(source)) {
+            this.recordKeysFromPublicKey(source.pub);
+        }
+        else {
+            throw new Error('Invalid key pair options');
+        }
+    }
+    KeyPair.prototype.setKP = function (keyPair) {
+        this.keyPair = {
+            prv: utils_1.Uint8ArrayTobase58(keyPair.secretKey),
+            pub: keyPair.publicKey.toString(),
+        };
+    };
+    /** @inheritdoc */
+    KeyPair.prototype.recordKeysFromPrivateKey = function (prv) {
+        if (utils_1.isValidPrivateKey(prv)) {
+            var prvKey = utils_1.base58ToUint8Array(prv);
+            var keyPair = web3_js_1.Keypair.fromSecretKey(prvKey);
+            this.setKP(keyPair);
+        }
+        else {
+            throw new errors_1.InvalidKey('Invalid private key');
+        }
+    };
+    /** @inheritdoc */
+    KeyPair.prototype.recordKeysFromPublicKey = function (pub) {
+        if (utils_1.isValidPublicKey(pub)) {
+            this.keyPair = { pub: pub };
+        }
+        else {
+            throw new errors_1.InvalidKey('Invalid public key: ' + pub);
+        }
+    };
+    /**
+     * Solana default keys format public key as a base58 string and secret key as Uint8Array
+     *
+     * @param {boolean} raw defines if the prv key is returned in Uint8Array, default is base58
+     * @returns {SolanaKeys} The keys in the defined format
+     */
+    KeyPair.prototype.getKeys = function (raw) {
+        if (raw === void 0) { raw = false; }
+        var result = { pub: this.keyPair.pub };
+        if (!!this.keyPair.prv) {
+            if (raw) {
+                result.prv = utils_1.base58ToUint8Array(this.keyPair.prv);
+            }
+            else {
+                result.prv = this.keyPair.prv;
+            }
+        }
+        return result;
+    };
+    /** @inheritdoc */
+    KeyPair.prototype.getAddress = function () {
+        var keys = this.getKeys();
+        return keys.pub;
+    };
+    /**
+     * Generates a signature for an arbitrary string with the current private key using the ed25519 public-key signature
+     * system.
+     *
+     * @param {string} message to produce a signature for
+     * @returns {Uint8Array} The signature produced for the message
+     * @throws if there is no private key
+     */
+    KeyPair.prototype.signMessage = function (message) {
+        var messageToSign = new Uint8Array(Buffer.from(message));
+        var prv = this.keyPair.prv;
+        if (!prv) {
+            throw new Error('Missing private key');
+        }
+        return tweetnacl_1.default.sign.detached(messageToSign, utils_1.base58ToUint8Array(prv));
+    };
+    /**
+     * Verifies a message signature using the current public key.
+     *
+     * @param {string} message signed
+     * @param {Uint8Array} signature to verify
+     * @returns {boolean} True if the message was signed with the current key pair
+     */
+    KeyPair.prototype.verifySignature = function (message, signature) {
+        var messageToVerify;
+        if (typeof message === 'string') {
+            messageToVerify = new Uint8Array(Buffer.from(message));
+        }
+        else {
+            messageToVerify = message;
+        }
+        var pub = new web3_js_1.PublicKey(this.keyPair.pub);
+        return tweetnacl_1.default.sign.detached.verify(messageToVerify, signature, pub.toBuffer());
+    };
+    return KeyPair;
+}());
+exports.KeyPair = KeyPair;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPair.js","sourceRoot":"","sources":["../../../../src/coin/sol/keyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import { Keypair as SolKeypair, PublicKey } from '@solana/web3.js';\nimport nacl from 'tweetnacl';\nimport { BaseKeyPair } from '../baseCoin';\nimport { InvalidKey } from '../baseCoin/errors';\nimport { DefaultKeys, isPrivateKey, isPublicKey, isSeed, KeyPairOptions } from '../baseCoin/iface';\nimport { SEED_LENGTH } from './constants';\nimport { SolanaKeys } from './iface';\nimport { base58ToUint8Array, isValidPrivateKey, isValidPublicKey, Uint8ArrayTobase58 } from './utils';\n\n// The Solana Key Pair is an ED25519 but the current ED25519 implementation doesnt return base58 strings\n// TODO(): Refactor to ED25519 Keypair instead of BaseKeyPair\nexport class KeyPair implements BaseKeyPair {\n  protected keyPair: DefaultKeys;\n  protected source?: KeyPairOptions;\n  /**\n   * Public constructor. By default, creates a key pair with a random master seed.\n   *\n   * @param { KeyPairOptions } source Either a master seed, a private key, or a public key\n   */\n  constructor(source?: KeyPairOptions) {\n    let kp: SolKeypair;\n    if (!source) {\n      kp = SolKeypair.generate();\n      this.setKP(kp);\n    } else if (isSeed(source)) {\n      kp = SolKeypair.fromSeed(source.seed.slice(0, SEED_LENGTH));\n      this.setKP(kp);\n    } else if (isPrivateKey(source)) {\n      this.recordKeysFromPrivateKey(source.prv);\n    } else if (isPublicKey(source)) {\n      this.recordKeysFromPublicKey(source.pub);\n    } else {\n      throw new Error('Invalid key pair options');\n    }\n  }\n\n  private setKP(keyPair: SolKeypair): void {\n    this.keyPair = {\n      prv: Uint8ArrayTobase58(keyPair.secretKey),\n      pub: keyPair.publicKey.toString(),\n    };\n  }\n\n  /** @inheritdoc */\n  recordKeysFromPrivateKey(prv: string): void {\n    if (isValidPrivateKey(prv)) {\n      const prvKey = base58ToUint8Array(prv);\n      const keyPair = SolKeypair.fromSecretKey(prvKey);\n      this.setKP(keyPair);\n    } else {\n      throw new InvalidKey('Invalid private key');\n    }\n  }\n\n  /** @inheritdoc */\n  recordKeysFromPublicKey(pub: string): void {\n    if (isValidPublicKey(pub)) {\n      this.keyPair = { pub };\n    } else {\n      throw new InvalidKey('Invalid public key: ' + pub);\n    }\n  }\n\n  /**\n   * Solana default keys format public key as a base58 string and secret key as Uint8Array\n   *\n   * @param {boolean} raw defines if the prv key is returned in Uint8Array, default is base58\n   * @returns {SolanaKeys} The keys in the defined format\n   */\n  getKeys(raw = false): SolanaKeys {\n    const result: SolanaKeys = { pub: this.keyPair.pub };\n    if (!!this.keyPair.prv) {\n      if (raw) {\n        result.prv = base58ToUint8Array(this.keyPair.prv);\n      } else {\n        result.prv = this.keyPair.prv;\n      }\n    }\n    return result;\n  }\n\n  /** @inheritdoc */\n  getAddress(): string {\n    const keys = this.getKeys();\n    return keys.pub;\n  }\n\n  /**\n   * Generates a signature for an arbitrary string with the current private key using the ed25519 public-key signature\n   * system.\n   *\n   * @param {string} message to produce a signature for\n   * @returns {Uint8Array} The signature produced for the message\n   * @throws if there is no private key\n   */\n  signMessage(message: string): Uint8Array {\n    const messageToSign = new Uint8Array(Buffer.from(message));\n    const { prv } = this.keyPair;\n    if (!prv) {\n      throw new Error('Missing private key');\n    }\n    return nacl.sign.detached(messageToSign, base58ToUint8Array(prv));\n  }\n\n  /**\n   * Verifies a message signature using the current public key.\n   *\n   * @param {string} message signed\n   * @param {Uint8Array} signature to verify\n   * @returns {boolean} True if the message was signed with the current key pair\n   */\n  verifySignature(message: Uint8Array | string, signature: Uint8Array): boolean {\n    let messageToVerify;\n    if (typeof message === 'string') {\n      messageToVerify = new Uint8Array(Buffer.from(message));\n    } else {\n      messageToVerify = message;\n    }\n    const pub = new PublicKey(this.keyPair.pub);\n    return nacl.sign.detached.verify(messageToVerify, signature, pub.toBuffer());\n  }\n}\n"]}

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

@@ -0,0 +1,10 @@
+import { TransactionInstruction } from '@solana/web3.js';
+import { InstructionParams } from './iface';
+/**
+ * Construct Solana instructions from instructions params
+ *
+ * @param {InstructionParams} instructionToBuild - the data containing the instruction params
+ * @returns {TransactionInstruction[]} An array containing supported Solana instructions
+ */
+export declare function solInstructionFactory(instructionToBuild: InstructionParams): TransactionInstruction[];
+//# sourceMappingURL=solInstructionFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solInstructionFactory.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/solInstructionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAInF,OAAO,EAAE,iBAAiB,EAAqC,MAAM,SAAS,CAAC;AAE/E;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,iBAAiB,GAAG,sBAAsB,EAAE,CAarG"}

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

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solInstructionFactory = void 0;
+var web3_js_1 = require("@solana/web3.js");
+var assert_1 = __importDefault(require("assert"));
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var constants_1 = require("./constants");
+/**
+ * Construct Solana instructions from instructions params
+ *
+ * @param {InstructionParams} instructionToBuild - the data containing the instruction params
+ * @returns {TransactionInstruction[]} An array containing supported Solana instructions
+ */
+function solInstructionFactory(instructionToBuild) {
+    switch (instructionToBuild.type) {
+        case constants_1.InstructionBuilderTypes.NonceAdvance:
+            return advanceNonceInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.Memo:
+            return memoInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.Transfer:
+            return transferInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.CreateNonceAccount:
+            return createNonceAccountInstruction(instructionToBuild);
+        default:
+            throw new Error("Invalid instruction type or not supported");
+    }
+}
+exports.solInstructionFactory = solInstructionFactory;
+/**
+ * Construct Advance Nonce Solana instructions
+ *
+ * @param {Nonce} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction
+ */
+function advanceNonceInstruction(data) {
+    var _a = data.params, authWalletAddress = _a.authWalletAddress, walletNonceAddress = _a.walletNonceAddress;
+    assert_1.default(authWalletAddress, 'Missing authWalletAddress param');
+    assert_1.default(walletNonceAddress, 'Missing walletNonceAddress param');
+    var nonceInstruction = web3_js_1.SystemProgram.nonceAdvance({
+        noncePubkey: new web3_js_1.PublicKey(walletNonceAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(authWalletAddress),
+    });
+    return [nonceInstruction];
+}
+/**
+ * Construct Memo Solana instructions
+ *
+ * @param {Memo} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Memo Solana instruction
+ */
+function memoInstruction(data) {
+    var memo = data.params.memo;
+    assert_1.default(memo, 'Missing memo param');
+    var memoInstruction = new web3_js_1.TransactionInstruction({
+        keys: [],
+        programId: new web3_js_1.PublicKey(constants_1.MEMO_PROGRAM_PK),
+        data: Buffer.from(memo),
+    });
+    return [memoInstruction];
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function transferInstruction(data) {
+    var _a = data.params, fromAddress = _a.fromAddress, toAddress = _a.toAddress, amount = _a.amount;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(toAddress, 'Missing toAddress param');
+    assert_1.default(amount, 'Missing toAddress param');
+    var transferInstruction = web3_js_1.SystemProgram.transfer({
+        fromPubkey: new web3_js_1.PublicKey(fromAddress),
+        toPubkey: new web3_js_1.PublicKey(toAddress),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    return [transferInstruction];
+}
+/**
+ * Construct Create and Initialize Nonce Solana instructions
+ *
+ * @param {WalletInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction
+ */
+function createNonceAccountInstruction(data) {
+    var _a = data.params, fromAddress = _a.fromAddress, nonceAddress = _a.nonceAddress, authAddress = _a.authAddress, amount = _a.amount;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(nonceAddress, 'Missing nonceAddress param');
+    assert_1.default(authAddress, 'Missing authAddress param');
+    assert_1.default(amount, 'Missing amount param');
+    var nonceAccountInstruction = web3_js_1.SystemProgram.createNonceAccount({
+        fromPubkey: new web3_js_1.PublicKey(fromAddress),
+        noncePubkey: new web3_js_1.PublicKey(nonceAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(authAddress),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    return nonceAccountInstruction.instructions;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"solInstructionFactory.js","sourceRoot":"","sources":["../../../../src/coin/sol/solInstructionFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';\nimport assert from 'assert';\nimport BigNumber from 'bignumber.js';\nimport { InstructionBuilderTypes, MEMO_PROGRAM_PK } from './constants';\nimport { InstructionParams, Memo, Nonce, Transfer, WalletInit } from './iface';\n\n/**\n * Construct Solana instructions from instructions params\n *\n * @param {InstructionParams} instructionToBuild - the data containing the instruction params\n * @returns {TransactionInstruction[]} An array containing supported Solana instructions\n */\nexport function solInstructionFactory(instructionToBuild: InstructionParams): TransactionInstruction[] {\n  switch (instructionToBuild.type) {\n    case InstructionBuilderTypes.NonceAdvance:\n      return advanceNonceInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Memo:\n      return memoInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Transfer:\n      return transferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CreateNonceAccount:\n      return createNonceAccountInstruction(instructionToBuild);\n    default:\n      throw new Error(`Invalid instruction type or not supported`);\n  }\n}\n\n/**\n * Construct Advance Nonce Solana instructions\n *\n * @param {Nonce} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction\n */\nfunction advanceNonceInstruction(data: Nonce): TransactionInstruction[] {\n  const {\n    params: { authWalletAddress, walletNonceAddress },\n  } = data;\n  assert(authWalletAddress, 'Missing authWalletAddress param');\n  assert(walletNonceAddress, 'Missing walletNonceAddress param');\n  const nonceInstruction = SystemProgram.nonceAdvance({\n    noncePubkey: new PublicKey(walletNonceAddress),\n    authorizedPubkey: new PublicKey(authWalletAddress),\n  });\n  return [nonceInstruction];\n}\n\n/**\n * Construct Memo Solana instructions\n *\n * @param {Memo} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Memo Solana instruction\n */\nfunction memoInstruction(data: Memo): TransactionInstruction[] {\n  const {\n    params: { memo },\n  } = data;\n  assert(memo, 'Missing memo param');\n  const memoInstruction = new TransactionInstruction({\n    keys: [],\n    programId: new PublicKey(MEMO_PROGRAM_PK),\n    data: Buffer.from(memo),\n  });\n  return [memoInstruction];\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction transferInstruction(data: Transfer): TransactionInstruction[] {\n  const {\n    params: { fromAddress, toAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(toAddress, 'Missing toAddress param');\n  assert(amount, 'Missing toAddress param');\n  const transferInstruction = SystemProgram.transfer({\n    fromPubkey: new PublicKey(fromAddress),\n    toPubkey: new PublicKey(toAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  return [transferInstruction];\n}\n\n/**\n * Construct Create and Initialize Nonce Solana instructions\n *\n * @param {WalletInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction\n */\nfunction createNonceAccountInstruction(data: WalletInit): TransactionInstruction[] {\n  const {\n    params: { fromAddress, nonceAddress, authAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(nonceAddress, 'Missing nonceAddress param');\n  assert(authAddress, 'Missing authAddress param');\n  assert(amount, 'Missing amount param');\n  const nonceAccountInstruction = SystemProgram.createNonceAccount({\n    fromPubkey: new PublicKey(fromAddress),\n    noncePubkey: new PublicKey(nonceAddress),\n    authorizedPubkey: new PublicKey(authAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  return nonceAccountInstruction.instructions;\n}\n"]}

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

@@ -0,0 +1,48 @@
+import { BaseTransaction, TransactionType } from '../baseCoin';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Transaction as SolTransaction } from '@solana/web3.js';
+import { TxData } from './iface';
+import { KeyPair } from '.';
+export declare class Transaction extends BaseTransaction {
+    private _solTransaction;
+    protected _type: TransactionType;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    get solTransaction(): SolTransaction;
+    set solTransaction(tx: SolTransaction);
+    set id(id: string);
+    get id(): string;
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    setTransactionType(transactionType: TransactionType): void;
+    /** @inheritdoc */
+    canSign(): boolean;
+    /**
+     * Signs transaction.
+     *
+     * @param {KeyPair} keyPair Signer keys.
+     */
+    sign(keyPair: KeyPair[] | KeyPair): Promise<void>;
+    /** @inheritdoc */
+    toBroadcastFormat(): string;
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    fromRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    toJson(): TxData;
+    /**
+     * Get the nonce from the Solana Transaction
+     * Throws if not set
+     */
+    private getNonce;
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs(): void;
+}
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAgC,WAAW,IAAI,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;AAK5B,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,eAAe,CAAiB;IACxC,SAAS,CAAC,KAAK,EAAE,eAAe,CAAC;gBAErB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,IAAI,cAAc,IAAI,cAAc,CAEnC;IAED,IAAI,cAAc,CAAC,EAAE,EAAE,cAAc,EAEpC;IAED,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,EAEhB;IAED,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;;;OAIG;IACH,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAI1D,kBAAkB;IAClB,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBvD,kBAAkB;IAClB,iBAAiB,IAAI,MAAM;IAiB3B;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAuBhD,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAchB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAUhB;;OAEG;IACH,oBAAoB,IAAI,IAAI;CAkC7B"}

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

@@ -0,0 +1,254 @@
+"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.Transaction = void 0;
+var baseCoin_1 = require("../baseCoin");
+var errors_1 = require("../baseCoin/errors");
+var web3_js_1 = require("@solana/web3.js");
+var bs58_1 = __importDefault(require("bs58"));
+var utils_1 = require("./utils");
+var instructionParamsFactory_1 = require("./instructionParamsFactory");
+var constants_1 = require("./constants");
+var Transaction = /** @class */ (function (_super) {
+    __extends(Transaction, _super);
+    function Transaction(_coinConfig) {
+        return _super.call(this, _coinConfig) || this;
+    }
+    Object.defineProperty(Transaction.prototype, "solTransaction", {
+        get: function () {
+            return this._solTransaction;
+        },
+        set: function (tx) {
+            this._solTransaction = tx;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Transaction.prototype, "id", {
+        get: function () {
+            return this._id;
+        },
+        set: function (id) {
+            this._id = id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    Transaction.prototype.setTransactionType = function (transactionType) {
+        this._type = transactionType;
+    };
+    /** @inheritdoc */
+    Transaction.prototype.canSign = function () {
+        return true;
+    };
+    /**
+     * Signs transaction.
+     *
+     * @param {KeyPair} keyPair Signer keys.
+     */
+    Transaction.prototype.sign = function (keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPairs, signers, _i, keyPairs_1, kp, keys;
+            var _a;
+            return __generator(this, function (_b) {
+                if (!this._solTransaction || !this._solTransaction.recentBlockhash) {
+                    throw new errors_1.SigningError('Nonce is required before signing');
+                }
+                if (!this._solTransaction || !this._solTransaction.feePayer) {
+                    throw new errors_1.SigningError('feePayer is required before signing');
+                }
+                keyPairs = keyPair instanceof Array ? keyPair : [keyPair];
+                signers = [];
+                for (_i = 0, keyPairs_1 = keyPairs; _i < keyPairs_1.length; _i++) {
+                    kp = keyPairs_1[_i];
+                    keys = kp.getKeys(true);
+                    if (!keys.prv) {
+                        throw new errors_1.SigningError('Missing private key');
+                    }
+                    signers.push({ publicKey: new web3_js_1.PublicKey(keys.pub), secretKey: keys.prv });
+                }
+                try {
+                    (_a = this._solTransaction).partialSign.apply(_a, signers);
+                }
+                catch (e) {
+                    throw e;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /** @inheritdoc */
+    Transaction.prototype.toBroadcastFormat = function () {
+        if (!this._solTransaction) {
+            throw new errors_1.ParseTransactionError('Empty transaction');
+        }
+        // The signatures can have null signatures (which means they are required but yet unsigned)
+        // In order to be able to serializer the txs, we have to change the requireAllSignatures based
+        // on if the TX is fully signed or not
+        var requireAllSignatures = utils_1.requiresAllSignatures(this._solTransaction.signatures);
+        try {
+            // Based on the recomendation encoding found here https://docs.solana.com/developing/clients/jsonrpc-api#sendtransaction
+            // We use base64 encoding
+            return this._solTransaction.serialize({ requireAllSignatures: requireAllSignatures }).toString('base64');
+        }
+        catch (e) {
+            throw e;
+        }
+    };
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    Transaction.prototype.fromRawTransaction = function (rawTransaction) {
+        try {
+            utils_1.isValidRawTransaction(rawTransaction);
+            this._solTransaction = web3_js_1.Transaction.from(Buffer.from(rawTransaction, 'base64'));
+            if (this._solTransaction.signature && this._solTransaction.signature !== null) {
+                this._id = bs58_1.default.encode(this._solTransaction.signature);
+            }
+            var transactionType = utils_1.getTransactionType(this._solTransaction);
+            switch (transactionType) {
+                case baseCoin_1.TransactionType.WalletInitialization:
+                    this.setTransactionType(baseCoin_1.TransactionType.WalletInitialization);
+                    break;
+                case baseCoin_1.TransactionType.Send:
+                    this.setTransactionType(baseCoin_1.TransactionType.Send);
+                    break;
+            }
+            this.loadInputsAndOutputs();
+        }
+        catch (e) {
+            throw e;
+        }
+    };
+    /** @inheritdoc */
+    Transaction.prototype.toJson = function () {
+        var _a;
+        if (!this._solTransaction) {
+            throw new errors_1.ParseTransactionError('Empty transaction');
+        }
+        var result = {
+            id: this.id,
+            feePayer: (_a = this._solTransaction.feePayer) === null || _a === void 0 ? void 0 : _a.toString(),
+            nonce: this.getNonce(),
+            numSignatures: utils_1.countNotNullSignatures(this._solTransaction.signatures),
+            instructionsData: instructionParamsFactory_1.instructionParamsFactory(this._type, this._solTransaction.instructions),
+        };
+        return result;
+    };
+    /**
+     * Get the nonce from the Solana Transaction
+     * Throws if not set
+     */
+    Transaction.prototype.getNonce = function () {
+        if (this._solTransaction.recentBlockhash) {
+            return this._solTransaction.recentBlockhash;
+        }
+        else if (this._solTransaction.nonceInfo) {
+            return this._solTransaction.nonceInfo.nonce;
+        }
+        else {
+            throw new errors_1.InvalidTransactionError('Nonce is not set');
+        }
+    };
+    /**
+     * Load the input and output data on this transaction.
+     */
+    Transaction.prototype.loadInputsAndOutputs = function () {
+        var _a;
+        if (!this._solTransaction || ((_a = this._solTransaction.instructions) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+            return;
+        }
+        var outputs = [];
+        var inputs = [];
+        var instructionParams = instructionParamsFactory_1.instructionParamsFactory(this.type, this._solTransaction.instructions);
+        for (var _i = 0, instructionParams_1 = instructionParams; _i < instructionParams_1.length; _i++) {
+            var instruction = instructionParams_1[_i];
+            switch (instruction.type) {
+                case constants_1.InstructionBuilderTypes.CreateNonceAccount:
+                    inputs.push({
+                        address: instruction.params.fromAddress,
+                        value: instruction.params.amount,
+                        coin: this._coinConfig.name,
+                    });
+                    break;
+                case constants_1.InstructionBuilderTypes.Transfer:
+                    inputs.push({
+                        address: instruction.params.fromAddress,
+                        value: instruction.params.amount,
+                        coin: this._coinConfig.name,
+                    });
+                    outputs.push({
+                        address: instruction.params.toAddress,
+                        value: instruction.params.amount,
+                        coin: this._coinConfig.name,
+                    });
+                    break;
+            }
+        }
+        this._outputs = outputs;
+        this._inputs = inputs;
+    };
+    return Transaction;
+}(baseCoin_1.BaseTransaction));
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../../src/coin/sol/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransaction, TransactionType } from '../baseCoin';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { InvalidTransactionError, ParseTransactionError, SigningError } from '../baseCoin/errors';\nimport { Blockhash, PublicKey, Signer, Transaction as SolTransaction } from '@solana/web3.js';\nimport { TxData } from './iface';\nimport base58 from 'bs58';\nimport { countNotNullSignatures, getTransactionType, isValidRawTransaction, requiresAllSignatures } from './utils';\nimport { KeyPair } from '.';\nimport { instructionParamsFactory } from './instructionParamsFactory';\nimport { InstructionBuilderTypes } from './constants';\nimport { Entry } from '../baseCoin/iface';\n\nexport class Transaction extends BaseTransaction {\n  private _solTransaction: SolTransaction;\n  protected _type: TransactionType;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  get solTransaction(): SolTransaction {\n    return this._solTransaction;\n  }\n\n  set solTransaction(tx: SolTransaction) {\n    this._solTransaction = tx;\n  }\n\n  set id(id: string) {\n    this._id = id;\n  }\n\n  get id(): string {\n    return this._id as string;\n  }\n\n  /**\n   * Set the transaction type.\n   *\n   * @param {TransactionType} transactionType The transaction type to be set.\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  /** @inheritdoc */\n  canSign(): boolean {\n    return true;\n  }\n\n  /**\n   * Signs transaction.\n   *\n   * @param {KeyPair} keyPair Signer keys.\n   */\n  async sign(keyPair: KeyPair[] | KeyPair): Promise<void> {\n    if (!this._solTransaction || !this._solTransaction.recentBlockhash) {\n      throw new SigningError('Nonce is required before signing');\n    }\n    if (!this._solTransaction || !this._solTransaction.feePayer) {\n      throw new SigningError('feePayer is required before signing');\n    }\n    const keyPairs = keyPair instanceof Array ? keyPair : [keyPair];\n    const signers: Signer[] = [];\n    for (const kp of keyPairs) {\n      const keys = kp.getKeys(true);\n      if (!keys.prv) {\n        throw new SigningError('Missing private key');\n      }\n      signers.push({ publicKey: new PublicKey(keys.pub), secretKey: keys.prv as Uint8Array });\n    }\n    try {\n      this._solTransaction.partialSign(...signers);\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /** @inheritdoc */\n  toBroadcastFormat(): string {\n    if (!this._solTransaction) {\n      throw new ParseTransactionError('Empty transaction');\n    }\n    // The signatures can have null signatures (which means they are required but yet unsigned)\n    // In order to be able to serializer the txs, we have to change the requireAllSignatures based\n    // on if the TX is fully signed or not\n    const requireAllSignatures = requiresAllSignatures(this._solTransaction.signatures);\n    try {\n      // Based on the recomendation encoding found here https://docs.solana.com/developing/clients/jsonrpc-api#sendtransaction\n      // We use base64 encoding\n      return this._solTransaction.serialize({ requireAllSignatures }).toString('base64');\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /**\n   * Sets this transaction payload\n   *\n   * @param rawTransaction\n   */\n  fromRawTransaction(rawTransaction: string): void {\n    try {\n      isValidRawTransaction(rawTransaction);\n      this._solTransaction = SolTransaction.from(Buffer.from(rawTransaction, 'base64'));\n\n      if (this._solTransaction.signature && this._solTransaction.signature !== null) {\n        this._id = base58.encode(this._solTransaction.signature);\n      }\n      const transactionType = getTransactionType(this._solTransaction);\n      switch (transactionType) {\n        case TransactionType.WalletInitialization:\n          this.setTransactionType(TransactionType.WalletInitialization);\n          break;\n        case TransactionType.Send:\n          this.setTransactionType(TransactionType.Send);\n          break;\n      }\n      this.loadInputsAndOutputs();\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /** @inheritdoc */\n  toJson(): TxData {\n    if (!this._solTransaction) {\n      throw new ParseTransactionError('Empty transaction');\n    }\n    const result: TxData = {\n      id: this.id,\n      feePayer: this._solTransaction.feePayer?.toString(),\n      nonce: this.getNonce(),\n      numSignatures: countNotNullSignatures(this._solTransaction.signatures),\n      instructionsData: instructionParamsFactory(this._type, this._solTransaction.instructions),\n    };\n    return result;\n  }\n\n  /**\n   * Get the nonce from the Solana Transaction\n   * Throws if not set\n   */\n  private getNonce(): Blockhash {\n    if (this._solTransaction.recentBlockhash) {\n      return this._solTransaction.recentBlockhash;\n    } else if (this._solTransaction.nonceInfo) {\n      return this._solTransaction.nonceInfo.nonce;\n    } else {\n      throw new InvalidTransactionError('Nonce is not set');\n    }\n  }\n\n  /**\n   * Load the input and output data on this transaction.\n   */\n  loadInputsAndOutputs(): void {\n    if (!this._solTransaction || this._solTransaction.instructions?.length === 0) {\n      return;\n    }\n    const outputs: Entry[] = [];\n    const inputs: Entry[] = [];\n    const instructionParams = instructionParamsFactory(this.type, this._solTransaction.instructions);\n\n    for (const instruction of instructionParams) {\n      switch (instruction.type) {\n        case InstructionBuilderTypes.CreateNonceAccount:\n          inputs.push({\n            address: instruction.params.fromAddress,\n            value: instruction.params.amount,\n            coin: this._coinConfig.name,\n          });\n          break;\n        case InstructionBuilderTypes.Transfer:\n          inputs.push({\n            address: instruction.params.fromAddress,\n            value: instruction.params.amount,\n            coin: this._coinConfig.name,\n          });\n          outputs.push({\n            address: instruction.params.toAddress,\n            value: instruction.params.amount,\n            coin: this._coinConfig.name,\n          });\n          break;\n      }\n    }\n    this._outputs = outputs;\n    this._inputs = inputs;\n  }\n}\n"]}