@solana/web3.js 1.39.1 → 1.41.0

package/lib/index.browser.cjs.js

@@ -1925,7 +1925,7 @@ class PublicKey extends Struct {
   /* eslint-disable require-await */
 
 
-  static async createProgramAddress(seeds, programId) {
+  static createProgramAddressSync(seeds, programId) {
     let buffer$1 = buffer.Buffer.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
@@ -1944,6 +1944,17 @@ class PublicKey extends Struct {
 
     return new PublicKey(publicKeyBytes);
   }
+  /**
+   * Async version of createProgramAddressSync
+   * For backwards compatibility
+   */
+
+  /* eslint-disable require-await */
+
+
+  static async createProgramAddress(seeds, programId) {
+    return this.createProgramAddressSync(seeds, programId);
+  }
   /**
    * Find a valid program address
    *
@@ -1953,14 +1964,14 @@ class PublicKey extends Struct {
    */
 
 
-  static async findProgramAddress(seeds, programId) {
+  static findProgramAddressSync(seeds, programId) {
     let nonce = 255;
     let address;
 
     while (nonce != 0) {
       try {
         const seedsWithNonce = seeds.concat(buffer.Buffer.from([nonce]));
-        address = await this.createProgramAddress(seedsWithNonce, programId);
+        address = this.createProgramAddressSync(seedsWithNonce, programId);
       } catch (err) {
         if (err instanceof TypeError) {
           throw err;
@@ -1975,13 +1986,23 @@ class PublicKey extends Struct {
 
     throw new Error(`Unable to find a viable program address nonce`);
   }
+  /**
+   * Async version of findProgramAddressSync
+   * For backwards compatibility
+   */
+
+
+  static async findProgramAddress(seeds, programId) {
+    return this.findProgramAddressSync(seeds, programId);
+  }
   /**
    * Check that a pubkey is on the ed25519 curve.
    */
 
 
-  static isOnCurve(pubkey) {
-    return is_on_curve(pubkey) == 1;
+  static isOnCurve(pubkeyData) {
+    const pubkey = new PublicKey(pubkeyData);
+    return is_on_curve(pubkey.toBytes()) == 1;
   }
 
 }
@@ -2468,13 +2489,11 @@ class Transaction {
         nonceInstruction: this.nonceInfo.nonceInstruction.toJSON()
       } : null,
       instructions: this.instructions.map(instruction => instruction.toJSON()),
-      signatures: this.signatures.map(({
-        publicKey,
-        signature
-      }) => ({
-        publicKey: publicKey.toJSON(),
-        signature: signature ? [...signature] : null
-      }))
+      signers: this.signatures.map(({
+        publicKey
+      }) => {
+        return publicKey.toJSON();
+      })
     };
   }
   /**
@@ -2506,7 +2525,7 @@ class Transaction {
   compileMessage() {
     if (this._message) {
       if (JSON.stringify(this.toJSON()) !== JSON.stringify(this._json)) {
-        throw new Error('Transaction mutated after being populated from Message');
+        throw new Error('Transaction message mutated after being populated from Message');
       }
 
       return this._message;
@@ -4085,6 +4104,136 @@ class BpfLoader {
 
 }
 
+/**
+ * Compute Budget Instruction class
+ */
+
+class ComputeBudgetInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Decode a compute budget instruction and retrieve the instruction type.
+   */
+
+
+  static decodeInstructionType(instruction) {
+    this.checkProgramId(instruction.programId);
+    const instructionTypeLayout = BufferLayout__namespace.u8('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+    let type;
+
+    for (const [ixType, layout] of Object.entries(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS)) {
+      if (layout.index == typeIndex) {
+        type = ixType;
+        break;
+      }
+    }
+
+    if (!type) {
+      throw new Error('Instruction type incorrect; not a ComputeBudgetInstruction');
+    }
+
+    return type;
+  }
+  /**
+   * Decode request units compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeRequestUnits(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      units,
+      additionalFee
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits, instruction.data);
+    return {
+      units,
+      additionalFee
+    };
+  }
+  /**
+   * Decode request heap frame compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeRequestHeapFrame(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      bytes
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame, instruction.data);
+    return {
+      bytes
+    };
+  }
+  /**
+   * @internal
+   */
+
+
+  static checkProgramId(programId) {
+    if (!programId.equals(ComputeBudgetProgram.programId)) {
+      throw new Error('invalid instruction; programId is not ComputeBudgetProgram');
+    }
+  }
+
+}
+/**
+ * An enumeration of valid ComputeBudgetInstructionType's
+ */
+
+/**
+ * An enumeration of valid ComputeBudget InstructionType's
+ * @internal
+ */
+const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
+  RequestUnits: {
+    index: 0,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('units'), BufferLayout__namespace.u32('additionalFee')])
+  },
+  RequestHeapFrame: {
+    index: 1,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('bytes')])
+  }
+});
+/**
+ * Factory class for transaction instructions to interact with the Compute Budget program
+ */
+
+class ComputeBudgetProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+  /**
+   * Public key that identifies the Compute Budget program
+   */
+
+
+  static requestUnits(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
+  static requestHeapFrame(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
+}
+ComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');
+
 var browserPonyfill = {exports: {}};
 
 (function (module, exports) {
@@ -5680,9 +5829,14 @@ const LogsNotificationResult = superstruct.type({
  * Filter for log subscriptions.
  */
 
+function createSubscriptionWarningMessage(id, label) {
+  return 'Ignored unsubscribe request because an active subscription ' + `with id \`${id}\` for '${label}' events could not be found.`;
+}
 /**
  * A connection to a fullnode JSON RPC endpoint
  */
+
+
 class Connection {
   /** @internal */
 
@@ -6882,6 +7036,33 @@ class Connection {
     });
     return res;
   }
+  /**
+   * Fetch transaction details for a batch of confirmed transactions.
+   * Similar to {@link getParsedTransactions} but returns a {@link TransactionResponse}.
+   */
+
+
+  async getTransactions(signatures, commitment) {
+    const batch = signatures.map(signature => {
+      const args = this._buildArgsAtLeastConfirmed([signature], commitment);
+
+      return {
+        methodName: 'getTransaction',
+        args
+      };
+    });
+    const unsafeRes = await this._rpcBatchRequest(batch);
+    const res = unsafeRes.map(unsafeRes => {
+      const res = superstruct.create(unsafeRes, GetTransactionRpcResult);
+
+      if ('error' in res) {
+        throw new Error('failed to get transactions: ' + res.error.message);
+      }
+
+      return res.result;
+    });
+    return res;
+  }
   /**
    * Fetch a list of Transactions and transaction statuses from the cluster
    * for a confirmed block.
@@ -7751,7 +7932,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown account change id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'account change'));
     }
   }
   /**
@@ -7817,7 +7998,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown program account change id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'program account change'));
     }
   }
   /**
@@ -7846,15 +8027,15 @@ class Connection {
 
 
   async removeOnLogsListener(id) {
-    if (!this._logsSubscriptions[id]) {
-      throw new Error(`Unknown logs id: ${id}`);
-    }
-
-    const subInfo = this._logsSubscriptions[id];
-    delete this._logsSubscriptions[id];
-    await this._unsubscribe(subInfo, 'logsUnsubscribe');
+    if (this._logsSubscriptions[id]) {
+      const subInfo = this._logsSubscriptions[id];
+      delete this._logsSubscriptions[id];
+      await this._unsubscribe(subInfo, 'logsUnsubscribe');
 
-    this._updateSubscriptions();
+      this._updateSubscriptions();
+    } else {
+      console.warn(createSubscriptionWarningMessage(id, 'logs'));
+    }
   }
   /**
    * @internal
@@ -7923,7 +8104,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown slot change id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'slot change'));
     }
   }
   /**
@@ -7976,7 +8157,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown slot update id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'slot update'));
     }
   }
 
@@ -8117,7 +8298,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown signature result id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'signature result'));
     }
   }
   /**
@@ -8169,7 +8350,7 @@ class Connection {
 
       this._updateSubscriptions();
     } else {
-      throw new Error(`Unknown root change id: ${id}`);
+      console.warn(createSubscriptionWarningMessage(id, 'root change'));
     }
   }
 
@@ -9856,6 +10037,9 @@ exports.BLOCKHASH_CACHE_TIMEOUT_MS = BLOCKHASH_CACHE_TIMEOUT_MS;
 exports.BPF_LOADER_DEPRECATED_PROGRAM_ID = BPF_LOADER_DEPRECATED_PROGRAM_ID;
 exports.BPF_LOADER_PROGRAM_ID = BPF_LOADER_PROGRAM_ID;
 exports.BpfLoader = BpfLoader;
+exports.COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS;
+exports.ComputeBudgetInstruction = ComputeBudgetInstruction;
+exports.ComputeBudgetProgram = ComputeBudgetProgram;
 exports.Connection = Connection;
 exports.Ed25519Program = Ed25519Program;
 exports.Enum = Enum;