@solana/web3.js 1.47.3 → 1.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.47.3",
+  "version": "1.49.0",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -23,6 +23,7 @@
     "./lib/index.cjs.js": "./lib/index.browser.cjs.js",
     "./lib/index.esm.js": "./lib/index.browser.esm.js"
   },
+  "react-native": "lib/index.native.js",
   "main": "lib/index.cjs.js",
   "module": "lib/index.esm.js",
   "types": "lib/index.d.ts",
@@ -68,6 +69,7 @@
     "jayson": "^3.4.4",
     "js-sha3": "^0.8.0",
     "node-fetch": "2",
+    "react-native-url-polyfill": "^1.3.0",
     "rpc-websockets": "^7.5.0",
     "secp256k1": "^4.0.2",
     "superstruct": "^0.14.2",

package/src/__forks__/react-native/fetch-impl.ts

@@ -0,0 +1,4 @@
+export const Headers = globalThis.Headers;
+export const Request = globalThis.Request;
+export const Response = globalThis.Response;
+export default globalThis.fetch;

package/src/address-lookup-table-program.ts

@@ -0,0 +1,433 @@
+import {toBufferLE} from 'bigint-buffer';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import * as Layout from './layout';
+import {PublicKey} from './publickey';
+import * as bigintLayout from './util/bigint';
+import {SystemProgram} from './system-program';
+import {TransactionInstruction} from './transaction';
+import {decodeData, encodeData, IInstructionInputData} from './instruction';
+
+export type CreateLookupTableParams = {
+  /** Account used to derive and control the new address lookup table. */
+  authority: PublicKey;
+  /** Account that will fund the new address lookup table. */
+  payer: PublicKey;
+  /** A recent slot must be used in the derivation path for each initialized table. */
+  recentSlot: bigint | number;
+};
+
+export type FreezeLookupTableParams = {
+  /** Address lookup table account to freeze. */
+  lookupTable: PublicKey;
+  /** Account which is the current authority. */
+  authority: PublicKey;
+};
+
+export type ExtendLookupTableParams = {
+  /** Address lookup table account to extend. */
+  lookupTable: PublicKey;
+  /** Account which is the current authority. */
+  authority: PublicKey;
+  /** Account that will fund the table reallocation.
+   * Not required if the reallocation has already been funded. */
+  payer?: PublicKey;
+  /** List of Public Keys to be added to the lookup table. */
+  addresses: Array<PublicKey>;
+};
+
+export type DeactivateLookupTableParams = {
+  /** Address lookup table account to deactivate. */
+  lookupTable: PublicKey;
+  /** Account which is the current authority. */
+  authority: PublicKey;
+};
+
+export type CloseLookupTableParams = {
+  /** Address lookup table account to close. */
+  lookupTable: PublicKey;
+  /** Account which is the current authority. */
+  authority: PublicKey;
+  /** Recipient of closed account lamports. */
+  recipient: PublicKey;
+};
+
+/**
+ * An enumeration of valid LookupTableInstructionType's
+ */
+export type LookupTableInstructionType =
+  | 'CreateLookupTable'
+  | 'ExtendLookupTable'
+  | 'CloseLookupTable'
+  | 'FreezeLookupTable'
+  | 'DeactivateLookupTable';
+
+type LookupTableInstructionInputData = {
+  CreateLookupTable: IInstructionInputData &
+    Readonly<{
+      recentSlot: bigint;
+      bumpSeed: number;
+    }>;
+  FreezeLookupTable: IInstructionInputData;
+  ExtendLookupTable: IInstructionInputData &
+    Readonly<{
+      numberOfAddresses: bigint;
+      addresses: Array<Uint8Array>;
+    }>;
+  DeactivateLookupTable: IInstructionInputData;
+  CloseLookupTable: IInstructionInputData;
+};
+
+/**
+ * An enumeration of valid address lookup table InstructionType's
+ * @internal
+ */
+export const LOOKUP_TABLE_INSTRUCTION_LAYOUTS = Object.freeze({
+  CreateLookupTable: {
+    index: 0,
+    layout: BufferLayout.struct<
+      LookupTableInstructionInputData['CreateLookupTable']
+    >([
+      BufferLayout.u32('instruction'),
+      bigintLayout.u64('recentSlot'),
+      BufferLayout.u8('bumpSeed'),
+    ]),
+  },
+  FreezeLookupTable: {
+    index: 1,
+    layout: BufferLayout.struct<
+      LookupTableInstructionInputData['FreezeLookupTable']
+    >([BufferLayout.u32('instruction')]),
+  },
+  ExtendLookupTable: {
+    index: 2,
+    layout: BufferLayout.struct<
+      LookupTableInstructionInputData['ExtendLookupTable']
+    >([
+      BufferLayout.u32('instruction'),
+      bigintLayout.u64(),
+      BufferLayout.seq(
+        Layout.publicKey(),
+        BufferLayout.offset(BufferLayout.u32(), -8),
+        'addresses',
+      ),
+    ]),
+  },
+  DeactivateLookupTable: {
+    index: 3,
+    layout: BufferLayout.struct<
+      LookupTableInstructionInputData['DeactivateLookupTable']
+    >([BufferLayout.u32('instruction')]),
+  },
+  CloseLookupTable: {
+    index: 4,
+    layout: BufferLayout.struct<
+      LookupTableInstructionInputData['CloseLookupTable']
+    >([BufferLayout.u32('instruction')]),
+  },
+});
+
+export class AddressLookupTableInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  static decodeInstructionType(
+    instruction: TransactionInstruction,
+  ): LookupTableInstructionType {
+    this.checkProgramId(instruction.programId);
+
+    const instructionTypeLayout = BufferLayout.u32('instruction');
+    const index = instructionTypeLayout.decode(instruction.data);
+
+    let type: LookupTableInstructionType | undefined;
+    for (const [layoutType, layout] of Object.entries(
+      LOOKUP_TABLE_INSTRUCTION_LAYOUTS,
+    )) {
+      if ((layout as any).index == index) {
+        type = layoutType as LookupTableInstructionType;
+        break;
+      }
+    }
+    if (!type) {
+      throw new Error(
+        'Invalid Instruction. Should be a LookupTable Instruction',
+      );
+    }
+    return type;
+  }
+
+  static decodeCreateLookupTable(
+    instruction: TransactionInstruction,
+  ): CreateLookupTableParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeysLength(instruction.keys, 4);
+
+    const {recentSlot} = decodeData(
+      LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable,
+      instruction.data,
+    );
+
+    return {
+      authority: instruction.keys[1].pubkey,
+      payer: instruction.keys[2].pubkey,
+      recentSlot: Number(recentSlot),
+    };
+  }
+
+  static decodeExtendLookupTable(
+    instruction: TransactionInstruction,
+  ): ExtendLookupTableParams {
+    this.checkProgramId(instruction.programId);
+    if (instruction.keys.length < 2) {
+      throw new Error(
+        `invalid instruction; found ${instruction.keys.length} keys, expected at least 2`,
+      );
+    }
+
+    const {addresses} = decodeData(
+      LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable,
+      instruction.data,
+    );
+    return {
+      lookupTable: instruction.keys[0].pubkey,
+      authority: instruction.keys[1].pubkey,
+      payer:
+        instruction.keys.length > 2 ? instruction.keys[2].pubkey : undefined,
+      addresses: addresses.map(buffer => new PublicKey(buffer)),
+    };
+  }
+
+  static decodeCloseLookupTable(
+    instruction: TransactionInstruction,
+  ): CloseLookupTableParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeysLength(instruction.keys, 3);
+
+    return {
+      lookupTable: instruction.keys[0].pubkey,
+      authority: instruction.keys[1].pubkey,
+      recipient: instruction.keys[2].pubkey,
+    };
+  }
+
+  static decodeFreezeLookupTable(
+    instruction: TransactionInstruction,
+  ): FreezeLookupTableParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeysLength(instruction.keys, 2);
+
+    return {
+      lookupTable: instruction.keys[0].pubkey,
+      authority: instruction.keys[1].pubkey,
+    };
+  }
+
+  static decodeDeactivateLookupTable(
+    instruction: TransactionInstruction,
+  ): DeactivateLookupTableParams {
+    this.checkProgramId(instruction.programId);
+    this.checkKeysLength(instruction.keys, 2);
+
+    return {
+      lookupTable: instruction.keys[0].pubkey,
+      authority: instruction.keys[1].pubkey,
+    };
+  }
+
+  /**
+   * @internal
+   */
+  static checkProgramId(programId: PublicKey) {
+    if (!programId.equals(AddressLookupTableProgram.programId)) {
+      throw new Error(
+        'invalid instruction; programId is not AddressLookupTable Program',
+      );
+    }
+  }
+  /**
+   * @internal
+   */
+  static checkKeysLength(keys: Array<any>, expectedLength: number) {
+    if (keys.length < expectedLength) {
+      throw new Error(
+        `invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`,
+      );
+    }
+  }
+}
+
+export class AddressLookupTableProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  static programId: PublicKey = new PublicKey(
+    'AddressLookupTab1e1111111111111111111111111',
+  );
+
+  static createLookupTable(params: CreateLookupTableParams) {
+    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync(
+      [params.authority.toBuffer(), toBufferLE(BigInt(params.recentSlot), 8)],
+      this.programId,
+    );
+
+    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;
+    const data = encodeData(type, {
+      recentSlot: BigInt(params.recentSlot),
+      bumpSeed: bumpSeed,
+    });
+
+    const keys = [
+      {
+        pubkey: lookupTableAddress,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: params.authority,
+        isSigner: true,
+        isWritable: false,
+      },
+      {
+        pubkey: params.payer,
+        isSigner: true,
+        isWritable: true,
+      },
+      {
+        pubkey: SystemProgram.programId,
+        isSigner: false,
+        isWritable: false,
+      },
+    ];
+
+    return [
+      new TransactionInstruction({
+        programId: this.programId,
+        keys: keys,
+        data: data,
+      }),
+      lookupTableAddress,
+    ] as [TransactionInstruction, PublicKey];
+  }
+
+  static freezeLookupTable(params: FreezeLookupTableParams) {
+    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.FreezeLookupTable;
+    const data = encodeData(type);
+
+    const keys = [
+      {
+        pubkey: params.lookupTable,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: params.authority,
+        isSigner: true,
+        isWritable: false,
+      },
+    ];
+
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys: keys,
+      data: data,
+    });
+  }
+
+  static extendLookupTable(params: ExtendLookupTableParams) {
+    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable;
+    const data = encodeData(type, {
+      addresses: params.addresses.map(addr => addr.toBytes()),
+    });
+
+    const keys = [
+      {
+        pubkey: params.lookupTable,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: params.authority,
+        isSigner: true,
+        isWritable: false,
+      },
+    ];
+
+    if (params.payer) {
+      keys.push(
+        {
+          pubkey: params.payer,
+          isSigner: true,
+          isWritable: true,
+        },
+        {
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false,
+        },
+      );
+    }
+
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys: keys,
+      data: data,
+    });
+  }
+
+  static deactivateLookupTable(params: DeactivateLookupTableParams) {
+    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.DeactivateLookupTable;
+    const data = encodeData(type);
+
+    const keys = [
+      {
+        pubkey: params.lookupTable,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: params.authority,
+        isSigner: true,
+        isWritable: false,
+      },
+    ];
+
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys: keys,
+      data: data,
+    });
+  }
+
+  static closeLookupTable(params: CloseLookupTableParams) {
+    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CloseLookupTable;
+    const data = encodeData(type);
+
+    const keys = [
+      {
+        pubkey: params.lookupTable,
+        isSigner: false,
+        isWritable: true,
+      },
+      {
+        pubkey: params.authority,
+        isSigner: true,
+        isWritable: false,
+      },
+      {
+        pubkey: params.recipient,
+        isSigner: false,
+        isWritable: true,
+      },
+    ];
+
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys: keys,
+      data: data,
+    });
+  }
+}

package/src/connection.ts

@@ -24,6 +24,7 @@ import type {Struct} from 'superstruct';
 import {Client as RpcWebSocketClient} from 'rpc-websockets';
 import RpcClient from 'jayson/lib/client/browser';
 
+import {URL} from './util/url-impl';
 import {AgentManager} from './agent-manager';
 import {EpochSchedule} from './epoch-schedule';
 import {SendTransactionError, SolanaJSONRPCError} from './errors';
@@ -41,7 +42,7 @@ import {
   TransactionExpiredBlockheightExceededError,
   TransactionExpiredTimeoutError,
 } from './util/tx-expiry-custom-errors';
-import {makeWebsocketUrl} from './util/url';
+import {makeWebsocketUrl} from './util/makeWebsocketUrl';
 import type {Blockhash} from './blockhash';
 import type {FeeCalculator} from './fee-calculator';
 import type {TransactionSignature} from './transaction';
@@ -442,6 +443,16 @@ export type GetBalanceConfig = {
   minContextSlot?: number;
 };
 
+/**
+ * Configuration object for changing `getBlock` query behavior
+ */
+export type GetBlockConfig = {
+  /** The level of finality desired */
+  commitment?: Finality;
+  /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
+  maxSupportedTransactionVersion?: number;
+};
+
 /**
  * Configuration object for changing `getBlockHeight` query behavior
  */
@@ -504,6 +515,16 @@ export type GetSlotLeaderConfig = {
   minContextSlot?: number;
 };
 
+/**
+ * Configuration object for changing `getTransaction` query behavior
+ */
+export type GetTransactionConfig = {
+  /** The level of finality desired */
+  commitment?: Finality;
+  /** The max transaction version to return in responses. If the requested transaction is a higher version, an error will be returned */
+  maxSupportedTransactionVersion?: number;
+};
+
 /**
  * Configuration object for changing `getLargestAccounts` query behavior
  */
@@ -711,13 +732,20 @@ export type SimulatedTransactionAccountInfo = {
   rentEpoch?: number;
 };
 
+export type TransactionReturnDataEncoding = 'base64';
+
+export type TransactionReturnData = {
+  programId: string;
+  data: [string, TransactionReturnDataEncoding];
+};
+
 export type SimulatedTransactionResponse = {
   err: TransactionError | string | null;
   logs: Array<string> | null;
   accounts?: (SimulatedTransactionAccountInfo | null)[] | null;
   unitsConsumed?: number;
+  returnData?: TransactionReturnData | null;
 };
-
 const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(
   pick({
     err: nullable(union([pick({}), string()])),
@@ -738,6 +766,14 @@ const SimulatedTransactionResponseStruct = jsonRpcResultAndContext(
       ),
     ),
     unitsConsumed: optional(number()),
+    returnData: optional(
+      nullable(
+        pick({
+          programId: string(),
+          data: tuple([string(), literal('base64')]),
+        }),
+      ),
+    ),
   }),
 );
 
@@ -3576,11 +3612,14 @@ export class Connection {
    */
   async getBlock(
     slot: number,
-    opts?: {commitment?: Finality},
+    rawConfig?: GetBlockConfig,
   ): Promise<BlockResponse | null> {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
     const args = this._buildArgsAtLeastConfirmed(
       [slot],
-      opts && opts.commitment,
+      commitment as Finality,
+      undefined /* encoding */,
+      config,
     );
     const unsafeRes = await this._rpcRequest('getBlock', args);
     const res = create(unsafeRes, GetBlockRpcResult);
@@ -3668,11 +3707,14 @@ export class Connection {
    */
   async getTransaction(
     signature: string,
-    opts?: {commitment?: Finality},
+    rawConfig?: GetTransactionConfig,
   ): Promise<TransactionResponse | null> {
+    const {commitment, config} = extractCommitmentFromConfig(rawConfig);
     const args = this._buildArgsAtLeastConfirmed(
       [signature],
-      opts && opts.commitment,
+      commitment as Finality,
+      undefined /* encoding */,
+      config,
     );
     const unsafeRes = await this._rpcRequest('getTransaction', args);
     const res = create(unsafeRes, GetTransactionRpcResult);

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './account';
+export * from './address-lookup-table-program';
 export * from './blockhash';
 export * from './bpf-loader-deprecated';
 export * from './bpf-loader';

package/src/layout.ts

@@ -135,13 +135,25 @@ export const voteInit = (property: string = 'voteInit') => {
 };
 
 export function getAlloc(type: any, fields: any): number {
-  let alloc = 0;
-  type.layout.fields.forEach((item: any) => {
+  const getItemAlloc = (item: any): number => {
     if (item.span >= 0) {
-      alloc += item.span;
+      return item.span;
     } else if (typeof item.alloc === 'function') {
-      alloc += item.alloc(fields[item.property]);
+      return item.alloc(fields[item.property]);
+    } else if ('count' in item && 'elementLayout' in item) {
+      const field = fields[item.property];
+      if (Array.isArray(field)) {
+        return field.length * getItemAlloc(item.elementLayout);
+      }
     }
+    // Couldn't determine allocated size of layout
+    return 0;
+  };
+
+  let alloc = 0;
+  type.layout.fields.forEach((item: any) => {
+    alloc += getItemAlloc(item);
   });
+
   return alloc;
 }

package/src/util/__forks__/react-native/url-impl.ts

@@ -0,0 +1,2 @@
+export {default} from 'react-native-url-polyfill';
+export * from 'react-native-url-polyfill';

package/src/util/{url.ts → makeWebsocketUrl.ts}

@@ -1,3 +1,5 @@
+import {URL} from './url-impl';
+
 export function makeWebsocketUrl(endpoint: string) {
   let url = new URL(endpoint);
   const useHttps = url.protocol === 'https:';

package/src/util/url-impl.ts

@@ -0,0 +1,2 @@
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;