@exodus/solana-lib 1.2.12 → 1.2.14

package/lib/vendor/system-program.js

@@ -0,0 +1,640 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SystemProgram = exports.SystemInstruction = exports.SYSTEM_INSTRUCTION_LAYOUTS = void 0;
+
+var BufferLayout = _interopRequireWildcard(require("@exodus/buffer-layout"));
+
+var _instruction = require("./instruction");
+
+var Layout = _interopRequireWildcard(require("./utils/layout"));
+
+var _nonceAccount = require("./nonce-account");
+
+var _publickey = require("./publickey");
+
+var _sysvar = require("./sysvar");
+
+var _transaction = require("./transaction");
+
+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; }
+
+/**
+ * An enumeration of valid system InstructionType's
+ */
+const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({
+  Create: {
+    index: 0,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports'), BufferLayout.ns64('space'), Layout.publicKey('programId')])
+  },
+  Assign: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('programId')])
+  },
+  Transfer: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  },
+  CreateWithSeed: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('base'), Layout.rustString('seed'), BufferLayout.ns64('lamports'), BufferLayout.ns64('space'), Layout.publicKey('programId')])
+  },
+  AdvanceNonceAccount: {
+    index: 4,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction')])
+  },
+  WithdrawNonceAccount: {
+    index: 5,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')])
+  },
+  InitializeNonceAccount: {
+    index: 6,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('authorized')])
+  },
+  AuthorizeNonceAccount: {
+    index: 7,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('authorized')])
+  },
+  Allocate: {
+    index: 8,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('space')])
+  },
+  AllocateWithSeed: {
+    index: 9,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('base'), Layout.rustString('seed'), BufferLayout.ns64('space'), Layout.publicKey('programId')])
+  },
+  AssignWithSeed: {
+    index: 10,
+    layout: BufferLayout.struct([BufferLayout.u32('instruction'), Layout.publicKey('base'), Layout.rustString('seed'), Layout.publicKey('programId')])
+  }
+});
+/**
+ * System Instruction class
+ */
+
+exports.SYSTEM_INSTRUCTION_LAYOUTS = SYSTEM_INSTRUCTION_LAYOUTS;
+
+class SystemInstruction {
+  /**
+   * Decode a system instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId);
+    const instructionTypeLayout = BufferLayout.u32('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+    let type;
+
+    for (const t of Object.keys(SYSTEM_INSTRUCTION_LAYOUTS)) {
+      if (SYSTEM_INSTRUCTION_LAYOUTS[t].index === typeIndex) {
+        type = t;
+      }
+    }
+
+    if (!type) {
+      throw new Error('Instruction type incorrect; not a SystemInstruction');
+    }
+
+    return type;
+  }
+  /**
+   * Decode a create account system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeCreateAccount(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 2);
+    const {
+      lamports,
+      space,
+      programId
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.Create, instruction.data);
+    return {
+      fromPubkey: instruction.keys[0].pubkey,
+      newAccountPubkey: instruction.keys[1].pubkey,
+      lamports,
+      space,
+      programId: new _publickey.PublicKey(programId)
+    };
+  }
+  /**
+   * Decode a transfer system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeTransfer(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 2);
+    const {
+      lamports
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.Transfer, instruction.data);
+    return {
+      fromPubkey: instruction.keys[0].pubkey,
+      toPubkey: instruction.keys[1].pubkey,
+      lamports
+    };
+  }
+  /**
+   * Decode an allocate system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAllocate(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 1);
+    const {
+      space
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.Allocate, instruction.data);
+    return {
+      accountPubkey: instruction.keys[0].pubkey,
+      space
+    };
+  }
+  /**
+   * Decode an allocate with seed system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAllocateWithSeed(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 1);
+    const {
+      base,
+      seed,
+      space,
+      programId
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed, instruction.data);
+    return {
+      accountPubkey: instruction.keys[0].pubkey,
+      basePubkey: new _publickey.PublicKey(base),
+      seed,
+      space,
+      programId: new _publickey.PublicKey(programId)
+    };
+  }
+  /**
+   * Decode an assign system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAssign(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 1);
+    const {
+      programId
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.Assign, instruction.data);
+    return {
+      accountPubkey: instruction.keys[0].pubkey,
+      programId: new _publickey.PublicKey(programId)
+    };
+  }
+  /**
+   * Decode an assign with seed system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeAssignWithSeed(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 1);
+    const {
+      base,
+      seed,
+      programId
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed, instruction.data);
+    return {
+      accountPubkey: instruction.keys[0].pubkey,
+      basePubkey: new _publickey.PublicKey(base),
+      seed,
+      programId: new _publickey.PublicKey(programId)
+    };
+  }
+  /**
+   * Decode a create account with seed system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeCreateWithSeed(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 2);
+    const {
+      base,
+      seed,
+      lamports,
+      space,
+      programId
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed, instruction.data);
+    return {
+      fromPubkey: instruction.keys[0].pubkey,
+      newAccountPubkey: instruction.keys[1].pubkey,
+      basePubkey: new _publickey.PublicKey(base),
+      seed,
+      lamports,
+      space,
+      programId: new _publickey.PublicKey(programId)
+    };
+  }
+  /**
+   * Decode a nonce initialize system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeNonceInitialize(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    const {
+      authorized
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount, instruction.data);
+    return {
+      noncePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: new _publickey.PublicKey(authorized)
+    };
+  }
+  /**
+   * Decode a nonce advance system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeNonceAdvance(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 3);
+    (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount, instruction.data);
+    return {
+      noncePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[2].pubkey
+    };
+  }
+  /**
+   * Decode a nonce withdraw system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeNonceWithdraw(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 5);
+    const {
+      lamports
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount, instruction.data);
+    return {
+      noncePubkey: instruction.keys[0].pubkey,
+      toPubkey: instruction.keys[1].pubkey,
+      authorizedPubkey: instruction.keys[4].pubkey,
+      lamports
+    };
+  }
+  /**
+   * Decode a nonce authorize system instruction and retrieve the instruction params.
+   */
+
+
+  static decodeNonceAuthorize(instruction) {
+    this.checkProgramId(instruction.programId);
+    this.checkKeyLength(instruction.keys, 2);
+    const {
+      authorized
+    } = (0, _instruction.decodeData)(SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount, instruction.data);
+    return {
+      noncePubkey: instruction.keys[0].pubkey,
+      authorizedPubkey: instruction.keys[1].pubkey,
+      newAuthorizedPubkey: new _publickey.PublicKey(authorized)
+    };
+  }
+  /**
+   * @private
+   */
+
+
+  static checkProgramId(programId) {
+    if (!programId.equals(SystemProgram.programId)) {
+      throw new Error('invalid instruction; programId is not SystemProgram');
+    }
+  }
+  /**
+   * @private
+   */
+
+
+  static checkKeyLength(keys, expectedLength) {
+    if (keys.length < expectedLength) {
+      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);
+    }
+  }
+
+}
+/**
+ * Factory class for transactions to interact with the System program
+ */
+
+
+exports.SystemInstruction = SystemInstruction;
+
+class SystemProgram {
+  /**
+   * Public key that identifies the System program
+   */
+  static get programId() {
+    return new _publickey.PublicKey('11111111111111111111111111111111');
+  }
+  /**
+   * Generate a transaction instruction that creates a new account
+   */
+
+
+  static createAccount(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.Create;
+    const data = (0, _instruction.encodeData)(type, {
+      lamports: params.lamports,
+      space: params.space,
+      programId: params.programId.toBuffer()
+    });
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.fromPubkey,
+        isSigner: true,
+        isWritable: true
+      }, {
+        pubkey: params.newAccountPubkey,
+        isSigner: true,
+        isWritable: true
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction instruction that transfers lamports from one account to another
+   */
+
+
+  static transfer(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
+    const data = (0, _instruction.encodeData)(type, {
+      lamports: params.lamports
+    });
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.fromPubkey,
+        isSigner: true,
+        isWritable: true
+      }, {
+        pubkey: params.toPubkey,
+        isSigner: false,
+        isWritable: true
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction instruction that assigns an account to a program
+   */
+
+
+  static assign(params) {
+    let data;
+
+    if (params.basePubkey) {
+      const type = SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed;
+      data = (0, _instruction.encodeData)(type, {
+        base: params.basePubkey.toBuffer(),
+        seed: params.seed,
+        programId: params.programId.toBuffer()
+      });
+    } else {
+      const type = SYSTEM_INSTRUCTION_LAYOUTS.Assign;
+      data = (0, _instruction.encodeData)(type, {
+        programId: params.programId.toBuffer()
+      });
+    }
+
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.accountPubkey,
+        isSigner: true,
+        isWritable: true
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction instruction that creates a new account at
+   *   an address generated with `from`, a seed, and programId
+   */
+
+
+  static createAccountWithSeed(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed;
+    const data = (0, _instruction.encodeData)(type, {
+      base: params.basePubkey.toBuffer(),
+      seed: params.seed,
+      lamports: params.lamports,
+      space: params.space,
+      programId: params.programId.toBuffer()
+    });
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.fromPubkey,
+        isSigner: true,
+        isWritable: true
+      }, {
+        pubkey: params.newAccountPubkey,
+        isSigner: false,
+        isWritable: true
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction that creates a new Nonce account
+   */
+
+
+  static createNonceAccount(params) {
+    const transaction = new _transaction.Transaction();
+
+    if (params.basePubkey && params.seed) {
+      transaction.add(SystemProgram.createAccountWithSeed({
+        fromPubkey: params.fromPubkey,
+        newAccountPubkey: params.noncePubkey,
+        basePubkey: params.basePubkey,
+        seed: params.seed,
+        lamports: params.lamports,
+        space: _nonceAccount.NONCE_ACCOUNT_LENGTH,
+        programId: this.programId
+      }));
+    } else {
+      transaction.add(SystemProgram.createAccount({
+        fromPubkey: params.fromPubkey,
+        newAccountPubkey: params.noncePubkey,
+        lamports: params.lamports,
+        space: _nonceAccount.NONCE_ACCOUNT_LENGTH,
+        programId: this.programId
+      }));
+    }
+
+    const initParams = {
+      noncePubkey: params.noncePubkey,
+      authorizedPubkey: params.authorizedPubkey
+    };
+    transaction.add(this.nonceInitialize(initParams));
+    return transaction;
+  }
+  /**
+   * Generate an instruction to initialize a Nonce account
+   */
+
+
+  static nonceInitialize(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount;
+    const data = (0, _instruction.encodeData)(type, {
+      authorized: params.authorizedPubkey.toBuffer()
+    });
+    const instructionData = {
+      keys: [{
+        pubkey: params.noncePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: _sysvar.SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    };
+    return new _transaction.TransactionInstruction(instructionData);
+  }
+  /**
+   * Generate an instruction to advance the nonce in a Nonce account
+   */
+
+
+  static nonceAdvance(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount;
+    const data = (0, _instruction.encodeData)(type);
+    const instructionData = {
+      keys: [{
+        pubkey: params.noncePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: params.authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    };
+    return new _transaction.TransactionInstruction(instructionData);
+  }
+  /**
+   * Generate a transaction instruction that withdraws lamports from a Nonce account
+   */
+
+
+  static nonceWithdraw(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount;
+    const data = (0, _instruction.encodeData)(type, {
+      lamports: params.lamports
+    });
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.noncePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: params.toPubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: _sysvar.SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: _sysvar.SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: params.authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction instruction that authorizes a new PublicKey as the authority
+   * on a Nonce account.
+   */
+
+
+  static nonceAuthorize(params) {
+    const type = SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount;
+    const data = (0, _instruction.encodeData)(type, {
+      authorized: params.newAuthorizedPubkey.toBuffer()
+    });
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.noncePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: params.authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction instruction that allocates space in an account without funding
+   */
+
+
+  static allocate(params) {
+    let data;
+
+    if (params.basePubkey) {
+      const type = SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed;
+      data = (0, _instruction.encodeData)(type, {
+        base: params.basePubkey.toBuffer(),
+        seed: params.seed,
+        space: params.space,
+        programId: params.programId.toBuffer()
+      });
+    } else {
+      const type = SYSTEM_INSTRUCTION_LAYOUTS.Allocate;
+      data = (0, _instruction.encodeData)(type, {
+        space: params.space
+      });
+    }
+
+    return new _transaction.TransactionInstruction({
+      keys: [{
+        pubkey: params.accountPubkey,
+        isSigner: true,
+        isWritable: true
+      }],
+      programId: this.programId,
+      data
+    });
+  }
+
+}
+
+exports.SystemProgram = SystemProgram;

package/lib/vendor/sysvar.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYSVAR_STAKE_HISTORY_PUBKEY = exports.SYSVAR_REWARDS_PUBKEY = exports.SYSVAR_RENT_PUBKEY = exports.SYSVAR_RECENT_BLOCKHASHES_PUBKEY = exports.SYSVAR_CLOCK_PUBKEY = void 0;
+
+var _publickey = require("./publickey");
+
+const SYSVAR_CLOCK_PUBKEY = new _publickey.PublicKey('SysvarC1ock11111111111111111111111111111111');
+exports.SYSVAR_CLOCK_PUBKEY = SYSVAR_CLOCK_PUBKEY;
+const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new _publickey.PublicKey('SysvarRecentB1ockHashes11111111111111111111');
+exports.SYSVAR_RECENT_BLOCKHASHES_PUBKEY = SYSVAR_RECENT_BLOCKHASHES_PUBKEY;
+const SYSVAR_RENT_PUBKEY = new _publickey.PublicKey('SysvarRent111111111111111111111111111111111');
+exports.SYSVAR_RENT_PUBKEY = SYSVAR_RENT_PUBKEY;
+const SYSVAR_REWARDS_PUBKEY = new _publickey.PublicKey('SysvarRewards111111111111111111111111111111');
+exports.SYSVAR_REWARDS_PUBKEY = SYSVAR_REWARDS_PUBKEY;
+const SYSVAR_STAKE_HISTORY_PUBKEY = new _publickey.PublicKey('SysvarStakeHistory1111111111111111111111111');
+exports.SYSVAR_STAKE_HISTORY_PUBKEY = SYSVAR_STAKE_HISTORY_PUBKEY;