@exodus/solana-lib 1.2.13 → 1.2.14

package/lib/vendor/transaction.js

@@ -0,0 +1,594 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transaction = exports.TransactionInstruction = exports.PACKET_DATA_SIZE = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _tweetnacl = _interopRequireDefault(require("tweetnacl"));
+
+var _bs = _interopRequireDefault(require("bs58"));
+
+var _message = require("./message");
+
+var _index = require("./index");
+
+var shortvec = _interopRequireWildcard(require("./utils/shortvec-encoding"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Default (empty) signature
+ *
+ * Signatures are 64 bytes in length
+ */
+const DEFAULT_SIGNATURE = Buffer.alloc(64).fill(0);
+/**
+ * Maximum over-the-wire size of a Transaction
+ *
+ * 1280 is IPv6 minimum MTU
+ * 40 bytes is the size of the IPv6 header
+ * 8 bytes is the size of the fragment header
+ */
+
+const PACKET_DATA_SIZE = 1280 - 40 - 8;
+exports.PACKET_DATA_SIZE = PACKET_DATA_SIZE;
+const SIGNATURE_LENGTH = 64;
+/**
+ * Account metadata used to define instructions
+ *
+ * @typedef {Object} AccountMeta
+ * @property {PublicKey} pubkey An account's public key
+ * @property {boolean} isSigner True if an instruction requires a transaction signature matching `pubkey`
+ * @property {boolean} isWritable True if the `pubkey` can be loaded as a read-write account.
+ */
+
+/**
+ * Transaction Instruction class
+ */
+class TransactionInstruction {
+  /**
+   * Public keys to include in this transaction
+   * Boolean represents whether this pubkey needs to sign the transaction
+   */
+
+  /**
+   * Program Id to execute
+   */
+
+  /**
+   * Program input
+   */
+  constructor(opts) {
+    _defineProperty(this, "keys", []);
+
+    _defineProperty(this, "programId", void 0);
+
+    _defineProperty(this, "data", Buffer.alloc(0));
+
+    opts && Object.assign(this, opts);
+  }
+
+}
+/**
+ * @private
+ */
+
+
+exports.TransactionInstruction = TransactionInstruction;
+
+/**
+ * Transaction class
+ */
+class Transaction {
+  /**
+   * Signatures for the transaction.  Typically created by invoking the
+   * `sign()` method
+   */
+
+  /**
+   * The first (payer) Transaction signature
+   */
+  get signature() {
+    if (this.signatures.length > 0) {
+      return this.signatures[0].signature;
+    }
+
+    return null;
+  }
+  /**
+   * The transaction fee payer (first signer)
+   */
+
+
+  get feePayer() {
+    if (this.signatures.length > 0) {
+      return this.signatures[0].publicKey;
+    }
+
+    return null;
+  }
+  /**
+   * The instructions to atomically execute
+   */
+
+
+  /**
+   * Construct an empty Transaction
+   */
+  constructor(opts) {
+    _defineProperty(this, "signatures", []);
+
+    _defineProperty(this, "instructions", []);
+
+    _defineProperty(this, "recentBlockhash", void 0);
+
+    _defineProperty(this, "nonceInfo", void 0);
+
+    opts && Object.assign(this, opts);
+  }
+  /**
+   * Add one or more instructions to this Transaction
+   */
+
+
+  add(...items) {
+    if (items.length === 0) {
+      throw new Error('No instructions');
+    }
+
+    items.forEach(item => {
+      if ('instructions' in item) {
+        this.instructions = this.instructions.concat(item.instructions);
+      } else if ('data' in item && 'programId' in item && 'keys' in item) {
+        this.instructions.push(item);
+      } else {
+        this.instructions.push(new TransactionInstruction(item));
+      }
+    });
+    return this;
+  }
+  /**
+   * Compile transaction data
+   */
+
+
+  compileMessage() {
+    const {
+      nonceInfo
+    } = this;
+
+    if (nonceInfo && this.instructions[0] !== nonceInfo.nonceInstruction) {
+      this.recentBlockhash = nonceInfo.nonce;
+      this.instructions.unshift(nonceInfo.nonceInstruction);
+    }
+
+    const {
+      recentBlockhash
+    } = this;
+
+    if (!recentBlockhash) {
+      throw new Error('Transaction recentBlockhash required');
+    }
+
+    if (this.instructions.length < 1) {
+      throw new Error('No instructions provided');
+    }
+
+    if (this.feePayer === null) {
+      throw new Error('Transaction feePayer required');
+    }
+
+    const programIds = [];
+    const accountMetas = [];
+    this.instructions.forEach(instruction => {
+      instruction.keys.forEach(accountMeta => {
+        accountMetas.push(_objectSpread({}, accountMeta));
+      });
+      const programId = instruction.programId.toString();
+
+      if (!programIds.includes(programId)) {
+        programIds.push(programId);
+      }
+    }); // Append programID account metas
+
+    programIds.forEach(programId => {
+      accountMetas.push({
+        pubkey: new _index.PublicKey(programId),
+        isSigner: false,
+        isWritable: false
+      });
+    }); // Sort. Prioritizing first by signer, then by writable
+
+    accountMetas.sort(function (x, y) {
+      const checkSigner = x.isSigner === y.isSigner ? 0 : x.isSigner ? -1 : 1;
+      const checkWritable = x.isWritable === y.isWritable ? 0 : x.isWritable ? -1 : 1;
+      return checkSigner || checkWritable;
+    }); // Cull duplicate account metas
+
+    const uniqueMetas = [];
+    accountMetas.forEach(accountMeta => {
+      const pubkeyString = accountMeta.pubkey.toString();
+      const uniqueIndex = uniqueMetas.findIndex(x => {
+        return x.pubkey.toString() === pubkeyString;
+      });
+
+      if (uniqueIndex > -1) {
+        uniqueMetas[uniqueIndex].isWritable = uniqueMetas[uniqueIndex].isWritable || accountMeta.isWritable;
+      } else {
+        uniqueMetas.push(accountMeta);
+      }
+    }); // Move payer to the front and disallow unknown signers
+
+    this.signatures.forEach((signature, signatureIndex) => {
+      const isPayer = signatureIndex === 0;
+      const uniqueIndex = uniqueMetas.findIndex(x => {
+        return x.pubkey.equals(signature.publicKey);
+      });
+
+      if (uniqueIndex > -1) {
+        if (isPayer) {
+          const [payerMeta] = uniqueMetas.splice(uniqueIndex, 1);
+          payerMeta.isSigner = true;
+          payerMeta.isWritable = true;
+          uniqueMetas.unshift(payerMeta);
+        } else {
+          uniqueMetas[uniqueIndex].isSigner = true;
+        }
+      } else if (isPayer) {
+        uniqueMetas.unshift({
+          pubkey: signature.publicKey,
+          isSigner: true,
+          isWritable: true
+        });
+      } else {
+        throw new Error(`unknown signer: ${signature.publicKey.toString()}`);
+      }
+    });
+    let numRequiredSignatures = 0;
+    let numReadonlySignedAccounts = 0;
+    let numReadonlyUnsignedAccounts = 0; // Split out signing from non-signing keys and count header values
+
+    const signedKeys = [];
+    const unsignedKeys = [];
+    uniqueMetas.forEach(({
+      pubkey,
+      isSigner,
+      isWritable
+    }) => {
+      if (isSigner) {
+        signedKeys.push(pubkey.toString());
+        numRequiredSignatures += 1;
+
+        if (!isWritable) {
+          numReadonlySignedAccounts += 1;
+        }
+      } else {
+        unsignedKeys.push(pubkey.toString());
+
+        if (!isWritable) {
+          numReadonlyUnsignedAccounts += 1;
+        }
+      }
+    });
+
+    if (numRequiredSignatures !== this.signatures.length) {
+      throw new Error(`missing signer(s) - required signatures: ${numRequiredSignatures}, got ${this.signatures.length}`);
+    }
+
+    const accountKeys = signedKeys.concat(unsignedKeys);
+    const instructions = this.instructions.map(instruction => {
+      const {
+        data,
+        programId
+      } = instruction;
+      return {
+        programIdIndex: accountKeys.indexOf(programId.toString()),
+        accounts: instruction.keys.map(keyObj => accountKeys.indexOf(keyObj.pubkey.toString())),
+        data: _bs.default.encode(data)
+      };
+    });
+    instructions.forEach(instruction => {
+      (0, _assert.default)(instruction.programIdIndex >= 0);
+      instruction.accounts.forEach(keyIndex => (0, _assert.default)(keyIndex >= 0));
+    });
+    return new _message.Message({
+      header: {
+        numRequiredSignatures,
+        numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts
+      },
+      accountKeys,
+      recentBlockhash,
+      instructions
+    });
+  }
+  /**
+   * Get a buffer of the Transaction data that need to be covered by signatures
+   */
+
+
+  serializeMessage() {
+    return this.compileMessage().serialize();
+  }
+  /**
+   * Specify the public keys which will be used to sign the Transaction.
+   * The first signer will be used as the transaction fee payer account.
+   *
+   * Signatures can be added with either `partialSign` or `addSignature`
+   */
+
+
+  setSigners(...signers) {
+    if (signers.length === 0) {
+      throw new Error('No signers');
+    }
+
+    const seen = new Set();
+    this.signatures = signers.filter(publicKey => {
+      const key = publicKey.toString();
+
+      if (seen.has(key)) {
+        return false;
+      } else {
+        seen.add(key);
+        return true;
+      }
+    }).map(publicKey => ({
+      signature: null,
+      publicKey
+    }));
+  }
+  /**
+   * Sign the Transaction with the specified accounts. Multiple signatures may
+   * be applied to a Transaction. The first signature is considered "primary"
+   * and is used when testing for Transaction confirmation. The first signer
+   * will be used as the transaction fee payer account.
+   *
+   * Transaction fields should not be modified after the first call to `sign`,
+   * as doing so may invalidate the signature and cause the Transaction to be
+   * rejected.
+   *
+   * The Transaction must be assigned a valid `recentBlockhash` before invoking this method
+   */
+
+
+  sign(...signers) {
+    if (signers.length === 0) {
+      throw new Error('No signers');
+    }
+
+    const seen = new Set();
+    this.signatures = signers.filter(signer => {
+      const key = signer.publicKey.toString();
+
+      if (seen.has(key)) {
+        return false;
+      } else {
+        seen.add(key);
+        return true;
+      }
+    }).map(signer => ({
+      signature: null,
+      publicKey: signer.publicKey
+    }));
+    this.partialSign(...signers);
+  }
+  /**
+   * Partially sign a transaction with the specified accounts. All accounts must
+   * correspond to a public key that was previously provided to `setSigners`.
+   *
+   * All the caveats from the `sign` method apply to `partialSign`
+   */
+
+
+  partialSign(...signers) {
+    if (signers.length === 0) {
+      throw new Error('No signers');
+    }
+
+    const message = this.compileMessage();
+    this.signatures.sort(function (x, y) {
+      const xIndex = message.findSignerIndex(x.publicKey);
+      const yIndex = message.findSignerIndex(y.publicKey);
+      return xIndex < yIndex ? -1 : 1;
+    });
+    const signData = message.serialize();
+    signers.forEach(signer => {
+      const signature = _tweetnacl.default.sign.detached(signData, signer.secretKey);
+
+      this.addSignature(signer.publicKey, signature);
+    });
+  }
+  /**
+   * Add an externally created signature to a transaction. The public key
+   * must correspond to a public key that was previously provided to `setSigners`.
+   */
+
+
+  addSignature(pubkey, signature) {
+    (0, _assert.default)(signature.length === 64);
+    const index = this.signatures.findIndex(sigpair => pubkey.equals(sigpair.publicKey));
+
+    if (index < 0) {
+      throw new Error(`unknown signer: ${pubkey.toString()}`);
+    }
+
+    this.signatures[index].signature = Buffer.from(signature);
+  }
+  /**
+   * Verify signatures of a complete, signed Transaction
+   */
+
+
+  verifySignatures() {
+    return this._verifySignatures(this.serializeMessage(), true);
+  }
+  /**
+   * @private
+   */
+
+
+  _verifySignatures(signData, requireAllSignatures) {
+    for (const {
+      signature,
+      publicKey
+    } of this.signatures) {
+      if (signature === null) {
+        if (requireAllSignatures) {
+          return false;
+        }
+      } else {
+        if (!_tweetnacl.default.sign.detached.verify(signData, signature, publicKey.toBuffer())) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+  /**
+   * Serialize the Transaction in the wire format.
+   */
+
+
+  serialize(config) {
+    const {
+      requireAllSignatures,
+      verifySignatures
+    } = Object.assign({
+      requireAllSignatures: true,
+      verifySignatures: true
+    }, config);
+    const signData = this.serializeMessage();
+
+    if (verifySignatures && !this._verifySignatures(signData, requireAllSignatures)) {
+      throw new Error('Signature verification failed');
+    }
+
+    return this._serialize(signData);
+  }
+  /**
+   * @private
+   */
+
+
+  _serialize(signData) {
+    const {
+      signatures
+    } = this;
+    const signatureCount = [];
+    shortvec.encodeLength(signatureCount, signatures.length);
+    const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;
+    const wireTransaction = Buffer.alloc(transactionLength);
+    (0, _assert.default)(signatures.length < 256);
+    Buffer.from(signatureCount).copy(wireTransaction, 0);
+    signatures.forEach(({
+      signature
+    }, index) => {
+      if (signature !== null) {
+        (0, _assert.default)(signature.length === 64, `signature has invalid length`);
+        Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);
+      }
+    });
+    signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);
+    (0, _assert.default)(wireTransaction.length <= PACKET_DATA_SIZE, `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`);
+    return wireTransaction;
+  }
+  /**
+   * Deprecated method
+   * @private
+   */
+
+
+  get keys() {
+    (0, _assert.default)(this.instructions.length === 1);
+    return this.instructions[0].keys.map(keyObj => keyObj.pubkey);
+  }
+  /**
+   * Deprecated method
+   * @private
+   */
+
+
+  get programId() {
+    (0, _assert.default)(this.instructions.length === 1);
+    return this.instructions[0].programId;
+  }
+  /**
+   * Deprecated method
+   * @private
+   */
+
+
+  get data() {
+    (0, _assert.default)(this.instructions.length === 1);
+    return this.instructions[0].data;
+  }
+  /**
+   * Parse a wire transaction into a Transaction object.
+   */
+
+
+  static from(buffer) {
+    // Slice up wire data
+    let byteArray = [...buffer];
+    const signatureCount = shortvec.decodeLength(byteArray);
+    let signatures = [];
+
+    for (let i = 0; i < signatureCount; i++) {
+      const signature = byteArray.slice(0, SIGNATURE_LENGTH);
+      byteArray = byteArray.slice(SIGNATURE_LENGTH);
+      signatures.push(_bs.default.encode(Buffer.from(signature)));
+    }
+
+    return Transaction.populate(_message.Message.from(byteArray), signatures);
+  }
+  /**
+   * Populate Transaction object from message and signatures
+   */
+
+
+  static populate(message, signatures) {
+    const transaction = new Transaction();
+    transaction.recentBlockhash = message.recentBlockhash;
+    signatures.forEach((signature, index) => {
+      const sigPubkeyPair = {
+        signature: signature === _bs.default.encode(DEFAULT_SIGNATURE) ? null : _bs.default.decode(signature),
+        publicKey: message.accountKeys[index]
+      };
+      transaction.signatures.push(sigPubkeyPair);
+    });
+    message.instructions.forEach(instruction => {
+      const keys = instruction.accounts.map(account => {
+        const pubkey = message.accountKeys[account];
+        return {
+          pubkey,
+          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()),
+          isWritable: message.isAccountWritable(account)
+        };
+      });
+      transaction.instructions.push(new TransactionInstruction({
+        keys,
+        programId: message.accountKeys[instruction.programIdIndex],
+        data: _bs.default.decode(instruction.data)
+      }));
+    });
+    return transaction;
+  }
+
+}
+
+exports.Transaction = Transaction;

package/lib/vendor/utils/blockhash.js

@@ -0,0 +1 @@
+"use strict";

package/lib/vendor/utils/fee-calculator.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FeeCalculatorLayout = void 0;
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11
+ *
+ * @private
+ */
+const FeeCalculatorLayout = BufferLayout.nu64('lamportsPerSignature');
+/**
+ * @typedef {Object} FeeCalculator
+ * @property {number} lamportsPerSignature lamports Cost in lamports to validate a signature
+ */
+
+exports.FeeCalculatorLayout = FeeCalculatorLayout;