@meteora-ag/cp-amm-sdk 1.0.3 → 1.0.4

package/node_modules/@solana/web3.js/src/loader.ts

@@ -0,0 +1,267 @@
+import {Buffer} from 'buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {PublicKey} from './publickey';
+import {Transaction, PACKET_DATA_SIZE} from './transaction';
+import {MS_PER_SLOT} from './timing';
+import {SYSVAR_RENT_PUBKEY} from './sysvar';
+import {sendAndConfirmTransaction} from './utils/send-and-confirm-transaction';
+import {sleep} from './utils/sleep';
+import type {Connection} from './connection';
+import type {Signer} from './keypair';
+import {SystemProgram} from './programs/system';
+import {IInstructionInputData} from './instruction';
+
+// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
+// rest of the Transaction fields
+//
+// TODO: replace 300 with a proper constant for the size of the other
+// Transaction fields
+const CHUNK_SIZE = PACKET_DATA_SIZE - 300;
+
+/**
+ * Program loader interface
+ */
+export class Loader {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Amount of program data placed in each load Transaction
+   */
+  static chunkSize: number = CHUNK_SIZE;
+
+  /**
+   * Minimum number of signatures required to load a program not including
+   * retries
+   *
+   * Can be used to calculate transaction fees
+   */
+  static getMinNumSignatures(dataLength: number): number {
+    return (
+      2 * // Every transaction requires two signatures (payer + program)
+      (Math.ceil(dataLength / Loader.chunkSize) +
+        1 + // Add one for Create transaction
+        1) // Add one for Finalize transaction
+    );
+  }
+
+  /**
+   * Loads a generic program
+   *
+   * @param connection The connection to use
+   * @param payer System account that pays to load the program
+   * @param program Account to load the program into
+   * @param programId Public key that identifies the loader
+   * @param data Program octets
+   * @return true if program was loaded successfully, false if program was already loaded
+   */
+  static async load(
+    connection: Connection,
+    payer: Signer,
+    program: Signer,
+    programId: PublicKey,
+    data: Buffer | Uint8Array | Array<number>,
+  ): Promise<boolean> {
+    {
+      const balanceNeeded = await connection.getMinimumBalanceForRentExemption(
+        data.length,
+      );
+
+      // Fetch program account info to check if it has already been created
+      const programInfo = await connection.getAccountInfo(
+        program.publicKey,
+        'confirmed',
+      );
+
+      let transaction: Transaction | null = null;
+      if (programInfo !== null) {
+        if (programInfo.executable) {
+          console.error('Program load failed, account is already executable');
+          return false;
+        }
+
+        if (programInfo.data.length !== data.length) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.allocate({
+              accountPubkey: program.publicKey,
+              space: data.length,
+            }),
+          );
+        }
+
+        if (!programInfo.owner.equals(programId)) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.assign({
+              accountPubkey: program.publicKey,
+              programId,
+            }),
+          );
+        }
+
+        if (programInfo.lamports < balanceNeeded) {
+          transaction = transaction || new Transaction();
+          transaction.add(
+            SystemProgram.transfer({
+              fromPubkey: payer.publicKey,
+              toPubkey: program.publicKey,
+              lamports: balanceNeeded - programInfo.lamports,
+            }),
+          );
+        }
+      } else {
+        transaction = new Transaction().add(
+          SystemProgram.createAccount({
+            fromPubkey: payer.publicKey,
+            newAccountPubkey: program.publicKey,
+            lamports: balanceNeeded > 0 ? balanceNeeded : 1,
+            space: data.length,
+            programId,
+          }),
+        );
+      }
+
+      // If the account is already created correctly, skip this step
+      // and proceed directly to loading instructions
+      if (transaction !== null) {
+        await sendAndConfirmTransaction(
+          connection,
+          transaction,
+          [payer, program],
+          {
+            commitment: 'confirmed',
+          },
+        );
+      }
+    }
+
+    const dataLayout = BufferLayout.struct<
+      Readonly<{
+        bytes: number[];
+        bytesLength: number;
+        bytesLengthPadding: number;
+        instruction: number;
+        offset: number;
+      }>
+    >([
+      BufferLayout.u32('instruction'),
+      BufferLayout.u32('offset'),
+      BufferLayout.u32('bytesLength'),
+      BufferLayout.u32('bytesLengthPadding'),
+      BufferLayout.seq(
+        BufferLayout.u8('byte'),
+        BufferLayout.offset(BufferLayout.u32(), -8),
+        'bytes',
+      ),
+    ]);
+
+    const chunkSize = Loader.chunkSize;
+    let offset = 0;
+    let array = data;
+    let transactions = [];
+    while (array.length > 0) {
+      const bytes = array.slice(0, chunkSize);
+      const data = Buffer.alloc(chunkSize + 16);
+      dataLayout.encode(
+        {
+          instruction: 0, // Load instruction
+          offset,
+          bytes: bytes as number[],
+          bytesLength: 0,
+          bytesLengthPadding: 0,
+        },
+        data,
+      );
+
+      const transaction = new Transaction().add({
+        keys: [{pubkey: program.publicKey, isSigner: true, isWritable: true}],
+        programId,
+        data,
+      });
+      transactions.push(
+        sendAndConfirmTransaction(connection, transaction, [payer, program], {
+          commitment: 'confirmed',
+        }),
+      );
+
+      // Delay between sends in an attempt to reduce rate limit errors
+      if (connection._rpcEndpoint.includes('solana.com')) {
+        const REQUESTS_PER_SECOND = 4;
+        await sleep(1000 / REQUESTS_PER_SECOND);
+      }
+
+      offset += chunkSize;
+      array = array.slice(chunkSize);
+    }
+    await Promise.all(transactions);
+
+    // Finalize the account loaded with program data for execution
+    {
+      const dataLayout = BufferLayout.struct<IInstructionInputData>([
+        BufferLayout.u32('instruction'),
+      ]);
+
+      const data = Buffer.alloc(dataLayout.span);
+      dataLayout.encode(
+        {
+          instruction: 1, // Finalize instruction
+        },
+        data,
+      );
+
+      const transaction = new Transaction().add({
+        keys: [
+          {pubkey: program.publicKey, isSigner: true, isWritable: true},
+          {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
+        ],
+        programId,
+        data,
+      });
+      const deployCommitment = 'processed';
+      const finalizeSignature = await connection.sendTransaction(
+        transaction,
+        [payer, program],
+        {preflightCommitment: deployCommitment},
+      );
+      const {context, value} = await connection.confirmTransaction(
+        {
+          signature: finalizeSignature,
+          lastValidBlockHeight: transaction.lastValidBlockHeight!,
+          blockhash: transaction.recentBlockhash!,
+        },
+        deployCommitment,
+      );
+      if (value.err) {
+        throw new Error(
+          `Transaction ${finalizeSignature} failed (${JSON.stringify(value)})`,
+        );
+      }
+      // We prevent programs from being usable until the slot after their deployment.
+      // See https://github.com/solana-labs/solana/pull/29654
+      while (
+        true // eslint-disable-line no-constant-condition
+      ) {
+        try {
+          const currentSlot = await connection.getSlot({
+            commitment: deployCommitment,
+          });
+          if (currentSlot > context.slot) {
+            break;
+          }
+        } catch {
+          /* empty */
+        }
+        await new Promise(resolve =>
+          setTimeout(resolve, Math.round(MS_PER_SLOT / 2)),
+        );
+      }
+    }
+
+    // success
+    return true;
+  }
+}

package/node_modules/@solana/web3.js/src/message/account-keys.ts

@@ -0,0 +1,79 @@
+import {LoadedAddresses} from '../connection';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import {MessageCompiledInstruction} from './index';
+
+export type AccountKeysFromLookups = LoadedAddresses;
+
+export class MessageAccountKeys {
+  staticAccountKeys: Array<PublicKey>;
+  accountKeysFromLookups?: AccountKeysFromLookups;
+
+  constructor(
+    staticAccountKeys: Array<PublicKey>,
+    accountKeysFromLookups?: AccountKeysFromLookups,
+  ) {
+    this.staticAccountKeys = staticAccountKeys;
+    this.accountKeysFromLookups = accountKeysFromLookups;
+  }
+
+  keySegments(): Array<Array<PublicKey>> {
+    const keySegments = [this.staticAccountKeys];
+    if (this.accountKeysFromLookups) {
+      keySegments.push(this.accountKeysFromLookups.writable);
+      keySegments.push(this.accountKeysFromLookups.readonly);
+    }
+    return keySegments;
+  }
+
+  get(index: number): PublicKey | undefined {
+    for (const keySegment of this.keySegments()) {
+      if (index < keySegment.length) {
+        return keySegment[index];
+      } else {
+        index -= keySegment.length;
+      }
+    }
+    return;
+  }
+
+  get length(): number {
+    return this.keySegments().flat().length;
+  }
+
+  compileInstructions(
+    instructions: Array<TransactionInstruction>,
+  ): Array<MessageCompiledInstruction> {
+    // Bail early if any account indexes would overflow a u8
+    const U8_MAX = 255;
+    if (this.length > U8_MAX + 1) {
+      throw new Error('Account index overflow encountered during compilation');
+    }
+
+    const keyIndexMap = new Map();
+    this.keySegments()
+      .flat()
+      .forEach((key, index) => {
+        keyIndexMap.set(key.toBase58(), index);
+      });
+
+    const findKeyIndex = (key: PublicKey) => {
+      const keyIndex = keyIndexMap.get(key.toBase58());
+      if (keyIndex === undefined)
+        throw new Error(
+          'Encountered an unknown instruction account key during compilation',
+        );
+      return keyIndex;
+    };
+
+    return instructions.map((instruction): MessageCompiledInstruction => {
+      return {
+        programIdIndex: findKeyIndex(instruction.programId),
+        accountKeyIndexes: instruction.keys.map(meta =>
+          findKeyIndex(meta.pubkey),
+        ),
+        data: instruction.data,
+      };
+    });
+  }
+}

package/node_modules/@solana/web3.js/src/message/compiled-keys.ts

@@ -0,0 +1,165 @@
+import {MessageHeader, MessageAddressTableLookup} from './index';
+import {AccountKeysFromLookups} from './account-keys';
+import {AddressLookupTableAccount} from '../programs';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
+import {PublicKey} from '../publickey';
+
+export type CompiledKeyMeta = {
+  isSigner: boolean;
+  isWritable: boolean;
+  isInvoked: boolean;
+};
+
+type KeyMetaMap = Map<string, CompiledKeyMeta>;
+
+export class CompiledKeys {
+  payer: PublicKey;
+  keyMetaMap: KeyMetaMap;
+
+  constructor(payer: PublicKey, keyMetaMap: KeyMetaMap) {
+    this.payer = payer;
+    this.keyMetaMap = keyMetaMap;
+  }
+
+  static compile(
+    instructions: Array<TransactionInstruction>,
+    payer: PublicKey,
+  ): CompiledKeys {
+    const keyMetaMap: KeyMetaMap = new Map();
+    const getOrInsertDefault = (pubkey: PublicKey): CompiledKeyMeta => {
+      const address = pubkey.toBase58();
+      let keyMeta = keyMetaMap.get(address);
+      if (keyMeta === undefined) {
+        keyMeta = {
+          isSigner: false,
+          isWritable: false,
+          isInvoked: false,
+        };
+        keyMetaMap.set(address, keyMeta);
+      }
+      return keyMeta;
+    };
+
+    const payerKeyMeta = getOrInsertDefault(payer);
+    payerKeyMeta.isSigner = true;
+    payerKeyMeta.isWritable = true;
+
+    for (const ix of instructions) {
+      getOrInsertDefault(ix.programId).isInvoked = true;
+      for (const accountMeta of ix.keys) {
+        const keyMeta = getOrInsertDefault(accountMeta.pubkey);
+        keyMeta.isSigner ||= accountMeta.isSigner;
+        keyMeta.isWritable ||= accountMeta.isWritable;
+      }
+    }
+
+    return new CompiledKeys(payer, keyMetaMap);
+  }
+
+  getMessageComponents(): [MessageHeader, Array<PublicKey>] {
+    const mapEntries = [...this.keyMetaMap.entries()];
+    assert(mapEntries.length <= 256, 'Max static account keys length exceeded');
+
+    const writableSigners = mapEntries.filter(
+      ([, meta]) => meta.isSigner && meta.isWritable,
+    );
+    const readonlySigners = mapEntries.filter(
+      ([, meta]) => meta.isSigner && !meta.isWritable,
+    );
+    const writableNonSigners = mapEntries.filter(
+      ([, meta]) => !meta.isSigner && meta.isWritable,
+    );
+    const readonlyNonSigners = mapEntries.filter(
+      ([, meta]) => !meta.isSigner && !meta.isWritable,
+    );
+
+    const header: MessageHeader = {
+      numRequiredSignatures: writableSigners.length + readonlySigners.length,
+      numReadonlySignedAccounts: readonlySigners.length,
+      numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+    };
+
+    // sanity checks
+    {
+      assert(
+        writableSigners.length > 0,
+        'Expected at least one writable signer key',
+      );
+      const [payerAddress] = writableSigners[0];
+      assert(
+        payerAddress === this.payer.toBase58(),
+        'Expected first writable signer key to be the fee payer',
+      );
+    }
+
+    const staticAccountKeys = [
+      ...writableSigners.map(([address]) => new PublicKey(address)),
+      ...readonlySigners.map(([address]) => new PublicKey(address)),
+      ...writableNonSigners.map(([address]) => new PublicKey(address)),
+      ...readonlyNonSigners.map(([address]) => new PublicKey(address)),
+    ];
+
+    return [header, staticAccountKeys];
+  }
+
+  extractTableLookup(
+    lookupTable: AddressLookupTableAccount,
+  ): [MessageAddressTableLookup, AccountKeysFromLookups] | undefined {
+    const [writableIndexes, drainedWritableKeys] =
+      this.drainKeysFoundInLookupTable(
+        lookupTable.state.addresses,
+        keyMeta =>
+          !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable,
+      );
+    const [readonlyIndexes, drainedReadonlyKeys] =
+      this.drainKeysFoundInLookupTable(
+        lookupTable.state.addresses,
+        keyMeta =>
+          !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable,
+      );
+
+    // Don't extract lookup if no keys were found
+    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {
+      return;
+    }
+
+    return [
+      {
+        accountKey: lookupTable.key,
+        writableIndexes,
+        readonlyIndexes,
+      },
+      {
+        writable: drainedWritableKeys,
+        readonly: drainedReadonlyKeys,
+      },
+    ];
+  }
+
+  /** @internal */
+  private drainKeysFoundInLookupTable(
+    lookupTableEntries: Array<PublicKey>,
+    keyMetaFilter: (keyMeta: CompiledKeyMeta) => boolean,
+  ): [Array<number>, Array<PublicKey>] {
+    const lookupTableIndexes = new Array();
+    const drainedKeys = new Array();
+
+    for (const [address, keyMeta] of this.keyMetaMap.entries()) {
+      if (keyMetaFilter(keyMeta)) {
+        const key = new PublicKey(address);
+        const lookupTableIndex = lookupTableEntries.findIndex(entry =>
+          entry.equals(key),
+        );
+        if (lookupTableIndex >= 0) {
+          assert(lookupTableIndex < 256, 'Max lookup table index exceeded');
+          lookupTableIndexes.push(lookupTableIndex);
+          drainedKeys.push(key);
+          this.keyMetaMap.delete(address);
+        }
+      }
+    }
+
+    return [lookupTableIndexes, drainedKeys];
+  }
+}

package/node_modules/@solana/web3.js/src/message/index.ts

@@ -0,0 +1,47 @@
+import {PublicKey} from '../publickey';
+
+export * from './account-keys';
+// note: compiled-keys is internal and doesn't need to be exported
+export * from './legacy';
+export * from './versioned';
+export * from './v0';
+
+/**
+ * The message header, identifying signed and read-only account
+ */
+export type MessageHeader = {
+  /**
+   * The number of signatures required for this message to be considered valid. The
+   * signatures must match the first `numRequiredSignatures` of `accountKeys`.
+   */
+  numRequiredSignatures: number;
+  /** The last `numReadonlySignedAccounts` of the signed keys are read-only accounts */
+  numReadonlySignedAccounts: number;
+  /** The last `numReadonlySignedAccounts` of the unsigned keys are read-only accounts */
+  numReadonlyUnsignedAccounts: number;
+};
+
+/**
+ * An address table lookup used to load additional accounts
+ */
+export type MessageAddressTableLookup = {
+  accountKey: PublicKey;
+  writableIndexes: Array<number>;
+  readonlyIndexes: Array<number>;
+};
+
+/**
+ * An instruction to execute by a program
+ *
+ * @property {number} programIdIndex
+ * @property {number[]} accountKeyIndexes
+ * @property {Uint8Array} data
+ */
+export type MessageCompiledInstruction = {
+  /** Index into the transaction keys array indicating the program account that executes this instruction */
+  programIdIndex: number;
+  /** Ordered indices into the transaction keys array indicating which accounts to pass to the program */
+  accountKeyIndexes: number[];
+  /** The program input data */
+  data: Uint8Array;
+};