@exodus/solana-lib 1.2.13 → 1.2.14

package/lib/vendor/index.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _account = require("./account");
+
+Object.keys(_account).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _account[key];
+    }
+  });
+});
+
+var _instruction = require("./instruction");
+
+Object.keys(_instruction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _instruction[key];
+    }
+  });
+});
+
+var _message = require("./message");
+
+Object.keys(_message).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _message[key];
+    }
+  });
+});
+
+var _nonceAccount = require("./nonce-account");
+
+Object.keys(_nonceAccount).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nonceAccount[key];
+    }
+  });
+});
+
+var _publickey = require("./publickey");
+
+Object.keys(_publickey).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _publickey[key];
+    }
+  });
+});
+
+var _systemProgram = require("./system-program");
+
+Object.keys(_systemProgram).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _systemProgram[key];
+    }
+  });
+});
+
+var _stakeProgram = require("./stake-program");
+
+Object.keys(_stakeProgram).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _stakeProgram[key];
+    }
+  });
+});
+
+var _sysvar = require("./sysvar");
+
+Object.keys(_sysvar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sysvar[key];
+    }
+  });
+});
+
+var _transaction = require("./transaction");
+
+Object.keys(_transaction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _transaction[key];
+    }
+  });
+});

package/lib/vendor/instruction.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeData = encodeData;
+exports.decodeData = decodeData;
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+var Layout = _interopRequireWildcard(require("./utils/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; }
+
+/**
+ * Populate a buffer of instruction data using an InstructionType
+ */
+function encodeData(type, fields) {
+  const allocLength = type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields);
+  const data = Buffer.alloc(allocLength);
+  const layoutFields = Object.assign({
+    instruction: type.index
+  }, fields);
+  type.layout.encode(layoutFields, data);
+  return data;
+}
+/**
+ * Decode instruction data buffer using an InstructionType
+ */
+
+
+function decodeData(type, buffer) {
+  let data;
+
+  try {
+    data = type.layout.decode(buffer);
+  } catch (err) {
+    throw new Error('invalid instruction; ' + err);
+  }
+
+  if (data.instruction !== type.index) {
+    throw new Error(`invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`);
+  }
+
+  return data;
+}

package/lib/vendor/message.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Message = void 0;
+
+var _bs = _interopRequireDefault(require("bs58"));
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+var _publickey = require("./publickey");
+
+var Layout = _interopRequireWildcard(require("./utils/layout"));
+
+var _transaction = require("./transaction");
+
+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 _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; }
+
+const PUBKEY_LENGTH = 32;
+/**
+ * List of instructions to be processed atomically
+ */
+
+class Message {
+  constructor(args) {
+    _defineProperty(this, "header", void 0);
+
+    _defineProperty(this, "accountKeys", void 0);
+
+    _defineProperty(this, "recentBlockhash", void 0);
+
+    _defineProperty(this, "instructions", void 0);
+
+    this.header = args.header;
+    this.accountKeys = args.accountKeys.map(account => new _publickey.PublicKey(account));
+    this.recentBlockhash = args.recentBlockhash;
+    this.instructions = args.instructions;
+  }
+
+  isAccountWritable(index) {
+    return index < this.header.numRequiredSignatures - this.header.numReadonlySignedAccounts || index >= this.header.numRequiredSignatures && index < this.accountKeys.length - this.header.numReadonlyUnsignedAccounts;
+  }
+
+  findSignerIndex(signer) {
+    const index = this.accountKeys.findIndex(accountKey => {
+      return accountKey.equals(signer);
+    });
+
+    if (index < 0) {
+      throw new Error(`unknown signer: ${signer.toString()}`);
+    }
+
+    return index;
+  }
+
+  serialize() {
+    const numKeys = this.accountKeys.length;
+    let keyCount = [];
+    shortvec.encodeLength(keyCount, numKeys);
+    const instructions = this.instructions.map(instruction => {
+      const {
+        accounts,
+        programIdIndex
+      } = instruction;
+
+      const data = _bs.default.decode(instruction.data);
+
+      let keyIndicesCount = [];
+      shortvec.encodeLength(keyIndicesCount, accounts.length);
+      let dataCount = [];
+      shortvec.encodeLength(dataCount, data.length);
+      return {
+        programIdIndex,
+        keyIndicesCount: Buffer.from(keyIndicesCount),
+        keyIndices: Buffer.from(accounts),
+        dataLength: Buffer.from(dataCount),
+        data
+      };
+    });
+    let instructionCount = [];
+    shortvec.encodeLength(instructionCount, instructions.length);
+    let instructionBuffer = Buffer.alloc(_transaction.PACKET_DATA_SIZE);
+    Buffer.from(instructionCount).copy(instructionBuffer);
+    let instructionBufferLength = instructionCount.length;
+    instructions.forEach(instruction => {
+      const instructionLayout = BufferLayout.struct([BufferLayout.u8('programIdIndex'), BufferLayout.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'), BufferLayout.seq(BufferLayout.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'), BufferLayout.blob(instruction.dataLength.length, 'dataLength'), BufferLayout.seq(BufferLayout.u8('userdatum'), instruction.data.length, 'data')]);
+      const length = instructionLayout.encode(instruction, instructionBuffer, instructionBufferLength);
+      instructionBufferLength += length;
+    });
+    instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
+    const signDataLayout = BufferLayout.struct([BufferLayout.blob(1, 'numRequiredSignatures'), BufferLayout.blob(1, 'numReadonlySignedAccounts'), BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'), BufferLayout.blob(keyCount.length, 'keyCount'), BufferLayout.seq(Layout.publicKey('key'), numKeys, 'keys'), Layout.publicKey('recentBlockhash')]);
+    const transaction = {
+      numRequiredSignatures: Buffer.from([this.header.numRequiredSignatures]),
+      numReadonlySignedAccounts: Buffer.from([this.header.numReadonlySignedAccounts]),
+      numReadonlyUnsignedAccounts: Buffer.from([this.header.numReadonlyUnsignedAccounts]),
+      keyCount: Buffer.from(keyCount),
+      keys: this.accountKeys.map(key => key.toBuffer()),
+      recentBlockhash: _bs.default.decode(this.recentBlockhash)
+    };
+    let signData = Buffer.alloc(2048);
+    const length = signDataLayout.encode(transaction, signData);
+    instructionBuffer.copy(signData, length);
+    return signData.slice(0, length + instructionBuffer.length);
+  }
+  /**
+   * Decode a compiled message into a Message object.
+   */
+
+
+  static from(buffer) {
+    // Slice up wire data
+    let byteArray = [...buffer];
+    const numRequiredSignatures = byteArray.shift();
+    const numReadonlySignedAccounts = byteArray.shift();
+    const numReadonlyUnsignedAccounts = byteArray.shift();
+    const accountCount = shortvec.decodeLength(byteArray);
+    let accountKeys = [];
+
+    for (let i = 0; i < accountCount; i++) {
+      const account = byteArray.slice(0, PUBKEY_LENGTH);
+      byteArray = byteArray.slice(PUBKEY_LENGTH);
+      accountKeys.push(_bs.default.encode(Buffer.from(account)));
+    }
+
+    const recentBlockhash = byteArray.slice(0, PUBKEY_LENGTH);
+    byteArray = byteArray.slice(PUBKEY_LENGTH);
+    const instructionCount = shortvec.decodeLength(byteArray);
+    let instructions = [];
+
+    for (let i = 0; i < instructionCount; i++) {
+      let instruction = {};
+      instruction.programIdIndex = byteArray.shift();
+      const accountCount = shortvec.decodeLength(byteArray);
+      instruction.accounts = byteArray.slice(0, accountCount);
+      byteArray = byteArray.slice(accountCount);
+      const dataLength = shortvec.decodeLength(byteArray);
+      const data = byteArray.slice(0, dataLength);
+      instruction.data = _bs.default.encode(Buffer.from(data));
+      byteArray = byteArray.slice(dataLength);
+      instructions.push(instruction);
+    }
+
+    const messageArgs = {
+      header: {
+        numRequiredSignatures,
+        numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts
+      },
+      recentBlockhash: _bs.default.encode(Buffer.from(recentBlockhash)),
+      accountKeys,
+      instructions
+    };
+    return new Message(messageArgs);
+  }
+
+}
+
+exports.Message = Message;

package/lib/vendor/nonce-account.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NonceAccount = exports.NONCE_ACCOUNT_LENGTH = void 0;
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+var _publickey = require("./publickey");
+
+var Layout = _interopRequireWildcard(require("./utils/layout"));
+
+var _feeCalculator = require("./utils/fee-calculator");
+
+var _toBuffer = require("./utils/to-buffer");
+
+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 _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; }
+
+const NonceAccountLayout = BufferLayout.struct([BufferLayout.u32('version'), BufferLayout.u32('state'), Layout.publicKey('authorizedPubkey'), Layout.publicKey('nonce'), BufferLayout.struct([_feeCalculator.FeeCalculatorLayout], 'feeCalculator')]);
+const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+/**
+ * NonceAccount class
+ */
+
+exports.NONCE_ACCOUNT_LENGTH = NONCE_ACCOUNT_LENGTH;
+
+class NonceAccount {
+  constructor() {
+    _defineProperty(this, "authorizedPubkey", void 0);
+
+    _defineProperty(this, "nonce", void 0);
+
+    _defineProperty(this, "feeCalculator", void 0);
+  }
+
+  /**
+   * Deserialize NonceAccount from the account data.
+   *
+   * @param buffer account data
+   * @return NonceAccount
+   */
+  static fromAccountData(buffer) {
+    const nonceAccount = NonceAccountLayout.decode((0, _toBuffer.toBuffer)(buffer), 0);
+    nonceAccount.authorizedPubkey = new _publickey.PublicKey(nonceAccount.authorizedPubkey);
+    nonceAccount.nonce = new _publickey.PublicKey(nonceAccount.nonce).toString();
+    return nonceAccount;
+  }
+
+}
+
+exports.NonceAccount = NonceAccount;

package/lib/vendor/publickey.js

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PublicKey = exports.MAX_SEED_LENGTH = void 0;
+
+var _bn = _interopRequireDefault(require("bn.js"));
+
+var _bs = _interopRequireDefault(require("bs58"));
+
+var _tweetnacl = _interopRequireDefault(require("tweetnacl"));
+
+var _createHash = _interopRequireDefault(require("create-hash"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+// $FlowFixMe
+let naclLowLevel = _tweetnacl.default.lowlevel;
+/**
+ * Maximum length of derived pubkey seed
+ */
+
+const MAX_SEED_LENGTH = 32;
+/**
+ * A public key
+ */
+
+exports.MAX_SEED_LENGTH = MAX_SEED_LENGTH;
+
+class PublicKey {
+  /**
+   * Create a new PublicKey object
+   */
+  constructor(value) {
+    _defineProperty(this, "_bn", void 0);
+
+    if (typeof value === 'string') {
+      // assume base 58 encoding by default
+      const decoded = _bs.default.decode(value);
+
+      if (decoded.length !== 32) {
+        throw new Error(`Invalid public key input`);
+      }
+
+      this._bn = new _bn.default(decoded);
+    } else {
+      this._bn = new _bn.default(value);
+    }
+
+    if (this._bn.byteLength() > 32) {
+      throw new Error(`Invalid public key input`);
+    }
+  }
+  /**
+   * Checks if two publicKeys are equal
+   */
+
+
+  equals(publicKey) {
+    return this._bn.eq(publicKey._bn);
+  }
+  /**
+   * Return the base-58 representation of the public key
+   */
+
+
+  toBase58() {
+    return _bs.default.encode(this.toBuffer());
+  }
+  /**
+   * Return the Buffer representation of the public key
+   */
+
+
+  toBuffer() {
+    const b = this._bn.toArrayLike(Buffer);
+
+    if (b.length === 32) {
+      return b;
+    }
+
+    const zeroPad = Buffer.alloc(32);
+    b.copy(zeroPad, 32 - b.length);
+    return zeroPad;
+  }
+  /**
+   * Returns a string representation of the public key
+   */
+
+
+  toString() {
+    return this.toBase58();
+  }
+  /**
+   * Find a valid program address
+   *
+   * Valid program addresses must fall off the ed25519 curve.  This function
+   * iterates a nonce until it finds one that when combined with the seeds
+   * results in a valid program address.
+   * HACK: transformed in sync function
+   */
+
+
+  static findProgramAddress(seeds, programId) {
+    let nonce = 255;
+    let address;
+
+    while (nonce !== 0) {
+      try {
+        const seedsWithNonce = seeds.concat(Buffer.from([nonce]));
+        address = this.createProgramAddress(seedsWithNonce, programId);
+      } catch (err) {
+        nonce--;
+        continue;
+      }
+
+      return [address, nonce];
+    }
+
+    throw new Error('Unable to find a viable program address nonce');
+  }
+  /**
+   * Derive a public key from another key, a seed, and a program ID.
+   * HACK: transformed in sync function
+   */
+
+
+  static createWithSeed(fromPublicKey, seed, programId) {
+    const buffer = Buffer.concat([fromPublicKey.toBuffer(), Buffer.from(seed), programId.toBuffer()]);
+    const hash = (0, _createHash.default)('sha256').update(buffer).digest('hex');
+    return new PublicKey(Buffer.from(hash, 'hex'));
+  }
+  /**
+   * Derive a program address from seeds and a program ID.
+   */
+
+
+  static createProgramAddress(seeds, programId) {
+    let buffer = Buffer.alloc(0);
+    seeds.forEach(function (seed) {
+      if (seed.length > MAX_SEED_LENGTH) {
+        throw new Error('Max seed length exceeded');
+      }
+
+      buffer = Buffer.concat([buffer, Buffer.from(seed)]);
+    });
+    buffer = Buffer.concat([buffer, programId.toBuffer(), Buffer.from('ProgramDerivedAddress')]);
+    let hash = (0, _createHash.default)('sha256').update(buffer).digest('hex');
+    let publicKeyBytes = new _bn.default(hash, 16).toArray(null, 32);
+
+    if (isOnCurve(publicKeyBytes)) {
+      throw new Error('Invalid seeds, address must fall off the curve');
+    }
+
+    return new PublicKey(publicKeyBytes);
+  }
+
+} // Check that a pubkey is on the curve.
+// This function and its dependents were sourced from:
+// https://github.com/dchest/tweetnacl-js/blob/f1ec050ceae0861f34280e62498b1d3ed9c350c6/nacl.js#L792
+
+
+exports.PublicKey = PublicKey;
+
+function isOnCurve(p) {
+  let r = [naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf(), naclLowLevel.gf()];
+  let t = naclLowLevel.gf();
+  let chk = naclLowLevel.gf();
+  let num = naclLowLevel.gf();
+  let den = naclLowLevel.gf();
+  let den2 = naclLowLevel.gf();
+  let den4 = naclLowLevel.gf();
+  let den6 = naclLowLevel.gf();
+  naclLowLevel.set25519(r[2], gf1);
+  naclLowLevel.unpack25519(r[1], p);
+  naclLowLevel.S(num, r[1]);
+  naclLowLevel.M(den, num, naclLowLevel.D);
+  naclLowLevel.Z(num, num, r[2]);
+  naclLowLevel.A(den, r[2], den);
+  naclLowLevel.S(den2, den);
+  naclLowLevel.S(den4, den2);
+  naclLowLevel.M(den6, den4, den2);
+  naclLowLevel.M(t, den6, num);
+  naclLowLevel.M(t, t, den);
+  naclLowLevel.pow2523(t, t);
+  naclLowLevel.M(t, t, num);
+  naclLowLevel.M(t, t, den);
+  naclLowLevel.M(t, t, den);
+  naclLowLevel.M(r[0], t, den);
+  naclLowLevel.S(chk, r[0]);
+  naclLowLevel.M(chk, chk, den);
+  if (neq25519(chk, num)) naclLowLevel.M(r[0], r[0], I);
+  naclLowLevel.S(chk, r[0]);
+  naclLowLevel.M(chk, chk, den);
+  if (neq25519(chk, num)) return 0;
+  return 1;
+}
+
+let gf1 = naclLowLevel.gf([1]);
+let I = naclLowLevel.gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
+
+function neq25519(a, b) {
+  var c = new Uint8Array(32);
+  var d = new Uint8Array(32);
+  naclLowLevel.pack25519(c, a);
+  naclLowLevel.pack25519(d, b);
+  return naclLowLevel.crypto_verify_32(c, 0, d, 0);
+}