@exodus/solana-lib 1.2.13 → 1.2.14

package/lib/transaction.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _bs = _interopRequireDefault(require("bs58"));
+
+var _lodash = require("lodash");
+
+var _keypair = require("./keypair");
+
+var _encode = require("./encode");
+
+var _tokenTransfer = require("./helpers/tokenTransfer");
+
+var _vendor = require("./vendor");
+
+var _constants = require("./constants");
+
+var _tokens = _interopRequireDefault(require("./tokens"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Tx {
+  constructor({
+    from,
+    to,
+    amount,
+    recentBlockhash,
+    // fee, // (Fee per Signature: 5000 lamports)
+    // Tokens related:
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    // true when recipient balance !== 0
+    fromTokenAddresses // sender token addresses
+
+  } = {}) {
+    (0, _assert.default)(from, 'from is required');
+    (0, _assert.default)(to, 'to is required');
+    (0, _assert.default)(amount, 'amount is required');
+    (0, _assert.default)(typeof amount === 'number', 'amount must be a number');
+    (0, _assert.default)(recentBlockhash, 'recentBlockhash is required');
+
+    if (tokenName) {
+      (0, _assert.default)(typeof destinationAddressType !== 'undefined', 'destinationAddressType is required when sending tokens');
+      (0, _assert.default)(typeof isAssociatedTokenAccountActive !== 'undefined', 'isAssociatedTokenAccountActive is required when sending tokens'); // needed to create the recipient account
+
+      (0, _assert.default)(Array.isArray(fromTokenAddresses), 'fromTokenAddresses Array is required');
+    }
+
+    const token = _tokens.default.find(({
+      tokenName: name
+    }) => name === tokenName);
+
+    this.txObj = {
+      from,
+      to,
+      amount,
+      recentBlockhash,
+      token,
+      destinationAddressType,
+      isAssociatedTokenAccountActive,
+      fromTokenAddresses
+    };
+
+    if (token) {
+      // TOKEN transfer tx
+      this.buildTokenTransaction(this.txObj);
+    } else {
+      // SOL tx
+      this.buildSOLtransaction(this.txObj);
+    }
+  }
+
+  buildSOLtransaction({
+    from,
+    to,
+    amount,
+    recentBlockhash
+  }) {
+    const txInstruction = _vendor.SystemProgram.transfer({
+      fromPubkey: new _vendor.PublicKey(from),
+      toPubkey: new _vendor.PublicKey(to),
+      lamports: amount
+    });
+
+    this.transaction = new _vendor.Transaction({
+      instructions: [txInstruction],
+      recentBlockhash
+    });
+  }
+
+  buildTokenTransaction({
+    from,
+    to,
+    amount,
+    recentBlockhash,
+    token,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses
+  }) {
+    this.transaction = new _vendor.Transaction({
+      recentBlockhash
+    });
+    const isUnknown = destinationAddressType === null;
+    const isSOLaddress = destinationAddressType === 'solana'; // crete account instruction
+
+    if (isUnknown) throw new Error('Destination SOL balance cannot be zero (address not active)'); // cannot initialize without knowing the owner
+
+    if (isSOLaddress && !isAssociatedTokenAccountActive) this.transaction.add((0, _tokenTransfer.createAssociatedTokenAccount)(from, token.mintAddress, to));
+    let amountLeft = amount;
+    let amountToSend;
+
+    for (let {
+      ticker,
+      tokenAccountAddress,
+      balance
+    } of fromTokenAddresses) {
+      // need to add more of this instruction until we reach the desired balance (amount) to send
+      (0, _assert.default)(ticker === token.tokenSymbol, `Got unexpected ticker ${ticker}`);
+      if (amountLeft === 0) break;
+      balance = Number(balance);
+
+      if (balance >= amountLeft) {
+        amountToSend = amountLeft;
+        amountLeft = 0;
+      } else {
+        amountToSend = balance; // not enough balance
+
+        amountLeft -= amountToSend;
+      }
+
+      const dest = isSOLaddress ? (0, _encode.findAssociatedTokenAddress)(to, token.mintAddress) : to; // add transfer token instruction
+
+      this.transaction.add((0, _tokenTransfer.createTokenTransferInstruction)(from, tokenAccountAddress, dest, amountToSend));
+    }
+
+    (0, _assert.default)(amountLeft === 0, `Not enough balance to send ${amount} ${token.tokenSymbol}`);
+  }
+
+  static createStakeAccountTransaction({
+    address,
+    amount,
+    seed = _constants.SEED,
+    pool,
+    recentBlockhash
+  }) {
+    const fromPubkey = new _vendor.PublicKey(address);
+    const stakeAddress = (0, _encode.createStakeAddress)(address, seed);
+    const stakePublicKey = new _vendor.PublicKey(stakeAddress);
+    const poolKey = new _vendor.PublicKey(pool);
+    const authorized = new _vendor.Authorized(fromPubkey, fromPubkey); // staker, withdrawer
+
+    const lockup = new _vendor.Lockup(0, 0, fromPubkey); // no lockup
+    // create account instruction
+
+    const programTx = _vendor.StakeProgram.createAccountWithSeed({
+      fromPubkey,
+      stakePubkey: stakePublicKey,
+      basePubkey: fromPubkey,
+      seed,
+      authorized,
+      lockup,
+      lamports: amount // number
+
+    }); // delegate funds instruction
+
+
+    const delegateTx = _vendor.StakeProgram.delegate({
+      stakePubkey: stakePublicKey,
+      authorizedPubkey: fromPubkey,
+      votePubkey: poolKey // pool vote key
+
+    });
+
+    const transaction = new _vendor.Transaction({
+      recentBlockhash
+    }).add(programTx).add(delegateTx);
+    return transaction;
+  }
+
+  static undelegate({
+    address,
+    stakeAddresses,
+    recentBlockhash
+  }) {
+    // undelegate all stake addresses
+    (0, _assert.default)(Array.isArray(stakeAddresses), 'stakeAddresses Array is required');
+    const fromPubkey = new _vendor.PublicKey(address);
+    const transaction = new _vendor.Transaction({
+      recentBlockhash
+    });
+    stakeAddresses.forEach(stakeAddress => {
+      const stakePublicKey = new _vendor.PublicKey(stakeAddress);
+
+      const programTx = _vendor.StakeProgram.deactivate({
+        stakePubkey: stakePublicKey,
+        authorizedPubkey: fromPubkey
+      });
+
+      transaction.add(programTx);
+    });
+    return transaction;
+  }
+
+  static withdraw({
+    address,
+    stakeAddresses,
+    amount,
+    recentBlockhash
+  }) {
+    const fromPubkey = new _vendor.PublicKey(address);
+    const stakeAddress = Array.isArray(stakeAddresses) ? stakeAddresses[0] : stakeAddresses;
+    const stakePublicKey = new _vendor.PublicKey(stakeAddress);
+
+    const transaction = _vendor.StakeProgram.withdraw({
+      stakePubkey: stakePublicKey,
+      authorizedPubkey: fromPubkey,
+      toPubkey: fromPubkey,
+      lamports: amount
+    });
+
+    transaction.recentBlockhash = recentBlockhash;
+    return transaction;
+  }
+
+  static sign(tx, privateKey) {
+    if (!privateKey) throw new Error('Please provide a secretKey');
+    const {
+      secretKey
+    } = (0, _keypair.getKeyPairFromPrivateKey)(privateKey);
+    const signers = [new _vendor.Account(secretKey)];
+    let transaction = tx;
+    if (tx instanceof Tx) transaction = tx.transaction;
+    transaction.sign(...signers);
+
+    if (!transaction.signature) {
+      throw new Error('!signature'); // should never happen
+    }
+  }
+
+  serialize() {
+    const wireTransaction = this.transaction.serialize();
+    return wireTransaction.toString('base64');
+  }
+
+  static serialize(tx) {
+    let transaction = tx;
+    if (tx instanceof Tx) transaction = tx.transaction;
+    return transaction.serialize().toString('base64');
+  }
+
+  static decodeStakingTx(serialized) {
+    // as base64
+    const wireTransaction = Buffer.from(serialized, 'base64');
+
+    const tx = _vendor.Transaction.from(wireTransaction); // Transaction instance
+
+
+    const txId = _bs.default.encode(tx.signature);
+
+    const stakingInstructions = tx.instructions.filter(ix => ix.programId.toString() === _constants.STAKE_PROGRAM_ID.toString());
+    const isStakingTx = !!stakingInstructions.length;
+    if (!isStakingTx) return null; // normal transfer tx
+
+    const info = {
+      txId,
+      owner: tx.feePayer.toString() // SOL sender
+
+    };
+    const txDetails = stakingInstructions.reduce((info, ix) => {
+      const type = _vendor.StakeInstruction.decodeInstructionType(ix);
+
+      switch (type) {
+        case 'Delegate':
+          info.type = 'Delegate';
+          info.stakeAddress = (0, _lodash.get)(ix, 'keys[0].pubkey', '').toString();
+          info.validator = (0, _lodash.get)(ix, 'keys[1].pubkey', '').toString(); // pool
+
+          return info;
+
+        case 'Deactivate':
+          // undelegate
+          info.type = 'Deactivate';
+          info.stakeAddress = (0, _lodash.get)(ix, 'keys[0].pubkey', '').toString(); // TODO: could have multiple addresses undelegating
+
+          return info;
+
+        case 'Withdraw':
+          info.type = 'Withdraw';
+          info.stakeAddress = (0, _lodash.get)(ix, 'keys[0].pubkey', '').toString();
+
+          const {
+            lamports,
+            toPubkey
+          } = _vendor.StakeInstruction.decodeWithdraw(ix);
+
+          info.to = toPubkey.toString();
+          info.lamports = lamports.toString();
+          return info;
+
+        default:
+          // skip unknown instruction type
+          return info;
+      }
+    }, info);
+    return txDetails;
+  }
+
+  getTxId() {
+    if (!this.transaction.signature) {
+      throw new Error('Cannot get txId, tx is not signed');
+    }
+
+    return _bs.default.encode(this.transaction.signature);
+  }
+
+  static getTxId(tx) {
+    let transaction = tx;
+    if (tx instanceof Tx) transaction = tx.transaction;
+
+    if (!transaction.signature) {
+      throw new Error('Cannot get txId, tx is not signed');
+    }
+
+    return _bs.default.encode(transaction.signature);
+  }
+
+}
+
+var _default = Tx;
+exports.default = _default;

package/lib/tx/create-and-sign-tx.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAndSignTx = createAndSignTx;
+
+var _createUnsignedTx = require("./create-unsigned-tx");
+
+var _signUnsignedTx = require("./sign-unsigned-tx");
+
+function createAndSignTx(input, privateKey) {
+  const unsignedTx = (0, _createUnsignedTx.createUnsignedTx)(input);
+  return (0, _signUnsignedTx.signUnsignedTx)(unsignedTx, privateKey);
+}

package/{src → lib}/tx/create-unsigned-tx.js

@@ -1,6 +1,11 @@
-import type { UnsignedTransaction, ParsedTransaction } from '@exodus/models/lib/types'
+"use strict";
 
-export function createUnsignedTx({
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUnsignedTx = createUnsignedTx;
+
+function createUnsignedTx({
   asset,
   from,
   to,
@@ -10,14 +15,16 @@ export function createUnsignedTx({
   // Tokens related:
   tokenName,
   destinationAddressType,
-  isAssociatedTokenAccountActive, // true when recipient balance !== 0
-  fromTokenAddresses, // sender token addresses
+  isAssociatedTokenAccountActive,
+  // true when recipient balance !== 0
+  fromTokenAddresses,
+  // sender token addresses
   // Staking related:
   method,
   stakeAddresses,
   seed,
-  pool,
-}: ParsedTransaction): UnsignedTransaction {
+  pool
+}) {
   return {
     txData: {
       from,
@@ -34,10 +41,10 @@ export function createUnsignedTx({
       method,
       stakeAddresses,
       seed,
-      pool,
+      pool
     },
     txMeta: {
-      assetName: asset.name,
-    },
-  }
-}
+      assetName: asset.name
+    }
+  };
+}

package/lib/tx/index.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _signUnsignedTx = require("./sign-unsigned-tx");
+
+Object.keys(_signUnsignedTx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _signUnsignedTx[key];
+    }
+  });
+});
+
+var _parseUnsignedTx = require("./parse-unsigned-tx");
+
+Object.keys(_parseUnsignedTx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseUnsignedTx[key];
+    }
+  });
+});
+
+var _createUnsignedTx = require("./create-unsigned-tx");
+
+Object.keys(_createUnsignedTx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createUnsignedTx[key];
+    }
+  });
+});
+
+var _createAndSignTx = require("./create-and-sign-tx");
+
+Object.keys(_createAndSignTx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createAndSignTx[key];
+    }
+  });
+});

package/lib/tx/parse-unsigned-tx.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUnsignedTx = parseUnsignedTx;
+
+var _assets = _interopRequireDefault(require("@exodus/assets"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function parseUnsignedTx(unsignedTx) {
+  const asset = _assets.default.solana;
+
+  const _unsignedTx$txData = unsignedTx.txData,
+        {
+    from,
+    to,
+    recentBlockhash,
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+    method,
+    stakeAddresses,
+    seed,
+    pool
+  } = _unsignedTx$txData,
+        txData = _objectWithoutProperties(_unsignedTx$txData, ["from", "to", "recentBlockhash", "tokenName", "destinationAddressType", "isAssociatedTokenAccountActive", "fromTokenAddresses", "method", "stakeAddresses", "seed", "pool"]);
+
+  const amount = asset.currency.baseUnit(txData.amount);
+  const fee = asset.currency.baseUnit(txData.fee);
+  return {
+    asset,
+    from: [from],
+    to,
+    amount,
+    fee,
+    recentBlockhash,
+    // token related
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+    // staking related
+    method,
+    stakeAddresses,
+    seed,
+    pool
+  };
+}

package/lib/tx/sign-unsigned-tx.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.signUnsignedTx = signUnsignedTx;
+
+var _assets = _interopRequireDefault(require("@exodus/assets"));
+
+var _ = require("../");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function signUnsignedTx(unsignedTx, privateKey) {
+  const {
+    from,
+    to,
+    amount: unitAmount,
+    recentBlockhash,
+    // tokens related
+    tokenName,
+    destinationAddressType,
+    isAssociatedTokenAccountActive,
+    fromTokenAddresses,
+    // staking related
+    stakeAddresses,
+    method,
+    seed,
+    pool
+  } = unsignedTx.txData;
+  const asset = _assets.default.solana;
+  const address = from;
+  const amount = unitAmount ? asset.currency.baseUnit(unitAmount).toNumber() : unitAmount;
+  let tx;
+
+  switch (method) {
+    case 'delegate':
+      tx = _.Transaction.createStakeAccountTransaction({
+        address,
+        amount,
+        recentBlockhash,
+        seed,
+        pool
+      });
+      break;
+
+    case 'undelegate':
+      tx = _.Transaction.undelegate({
+        address,
+        stakeAddresses,
+        recentBlockhash
+      });
+      break;
+
+    case 'withdraw':
+      tx = _.Transaction.withdraw({
+        address,
+        stakeAddresses,
+        amount,
+        recentBlockhash
+      });
+      break;
+
+    default:
+      // SOL and Token tx
+      tx = new _.Transaction({
+        from,
+        to,
+        amount,
+        recentBlockhash,
+        tokenName,
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAddresses
+      });
+      break;
+  } // sign plain tx
+
+
+  _.Transaction.sign(tx, privateKey);
+
+  const rawTx = _.Transaction.serialize(tx);
+
+  const txId = _.Transaction.getTxId(tx);
+
+  return {
+    txId,
+    rawTx
+  };
+}

package/lib/vendor/account.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Account = void 0;
+
+var _publickey = require("./publickey");
+
+var _keypair = require("../keypair");
+
+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; }
+
+class Account {
+  /**
+   * Create a new Account object
+   *
+   * @param secretKey Secret key for the account
+   */
+  constructor(secretKey) {
+    _defineProperty(this, "_keypair", void 0);
+
+    if (secretKey) {
+      this._keypair = (0, _keypair.getKeyPairFromPrivateKey)(Buffer.from(secretKey, 'hex'));
+    } else {
+      throw new Error('Please provide a secretKey');
+    }
+  }
+  /**
+   * The public key for this account
+   */
+
+
+  get publicKey() {
+    return new _publickey.PublicKey(this._keypair.publicKey);
+  }
+  /**
+   * The **unencrypted** secret key for this account
+   */
+
+
+  get secretKey() {
+    return this._keypair.secretKey;
+  }
+
+}
+
+exports.Account = Account;