solana-labs · Nov 25, 2021 · Nov 25, 2021 · Nov 25, 2021 · Nov 25, 2021 · Nov 25, 2021
diff --git a/.eslintignore b/.eslintignore
@@ -4,7 +4,6 @@
 /deploy
 /doc
 /lib
-/module.flow.js
 /.eslintrc.js
 /test/.eslintrc.js
 /test/dist

diff --git a/.eslintrc.js b/.eslintrc.js
@@ -31,17 +31,10 @@ module.exports = {
         'newlines-between': 'always',
       },
     ],
-    indent: [
-      'error',
-      2,
-      {
-        MemberExpression: 1,
-        SwitchCase: 1,
-      },
-    ],
     'linebreak-style': ['error', 'unix'],
     'no-console': [0],
     'no-trailing-spaces': ['error'],
+    'no-undef': 'off',
     'no-unused-vars': 'off',
     quotes: [
       'error',

diff --git a/.flowconfig b/.flowconfig
diff --git a/.github/workflows/cicd.yml b/.github/workflows/cicd.yml
@@ -0,0 +1,48 @@
+name: CI/CD
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "lts/*"
+          cache: "npm"
+
+      - name: Build
+        run: |
+          sh -c "$(curl -sSfL https://release.solana.com/edge/install)"
+          PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"
+          solana --version
+          npm install -g npm@7
+          npm install
+          npm run build
+          ls -l lib
+          test -r lib/index.iife.js
+          test -r lib/index.cjs.js
+          test -r lib/index.esm.js
+          npm run ok
+          npm run codecov
+          npm run test:live-with-test-validator
+
+      - name: Publish NPM
+        run: |
+          npx semantic-release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Deploy Github Page
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./doc
diff --git a/.mocharc.js b/.mocharc.js
diff --git a/.prettierignore b/.prettierignore
@@ -1,3 +1,2 @@
 test/dist
-module.flow.js
 declarations
diff --git a/.travis/before_install.sh b/.travis/before_install.sh
@@ -1,14 +1,21 @@
 # |source| this file
 
-wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-sudo apt-add-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main"
-sudo apt-get update
-sudo apt-get install -y clang-7 --allow-unauthenticated
-sudo apt-get install -y openssl --allow-unauthenticated
-sudo apt-get install -y libssl-dev --allow-unauthenticated
-sudo apt-get install -y libssl1.1 --allow-unauthenticated
-clang-7 --version
+if [[ -n $TRAVIS ]]; then
+  wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+  sudo apt-add-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main"
+  sudo apt-get update
+  sudo apt-get install -y clang-7 --allow-unauthenticated
+  sudo apt-get install -y openssl --allow-unauthenticated
+  sudo apt-get install -y libssl-dev --allow-unauthenticated
+  sudo apt-get install -y libssl1.1 --allow-unauthenticated
+  clang-7 --version
+fi
 
 sh -c "$(curl -sSfL https://release.solana.com/edge/install)"
 PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"
 solana --version
+
+if [[ -n $GITHUB_ACTIONS ]]; then
+  echo "$HOME/.local/share/solana/install/active_release/bin" >> "$GITHUB_PATH"
+  npm install -g npm@7
+fi
diff --git a/.travis/script.sh b/.travis/script.sh
@@ -9,8 +9,6 @@ ls -l lib
 test -r lib/index.iife.js
 test -r lib/index.cjs.js
 test -r lib/index.esm.js
-npm run doc
-npm run lint
+npm run ok
 npm run codecov
 npm run test:live-with-test-validator
-npm run test:browser-with-test-validator
diff --git a/README.md b/README.md
@@ -23,7 +23,10 @@
 
 This is the Solana Javascript API built on the Solana [JSON RPC API](https://docs.solana.com/apps/jsonrpc-api)
 
-[Latest API Documentation](https://solana-labs.github.io/solana-web3.js/)
+## Documentation and examples
+
+ - [The Solana Cookbook](https://solanacookbook.com/) has extensive task-based documentation using this library.
+ - For more detail on individual functions, see the [latest API Documentation](https://solana-labs.github.io/solana-web3.js/)
 
 ## Installation
 
@@ -84,20 +87,11 @@ console.log(solanaWeb3);
 console.log(solanaWeb3);
 ```
 
-## Examples
-
-Example scripts for the web3.js repo and native programs:
-
-- [Web3 Examples](https://github.com/solana-labs/solana/tree/master/web3.js/examples)
-
-Example scripts for the Solana Program Library:
-
-- [Token Program Examples](https://github.com/solana-labs/solana-program-library/tree/master/token/js/examples)
-
-## Flow
+## Flow Support (Discontinued)
 
-A [Flow library definition](https://flow.org/en/docs/libdefs/) is provided at
-https://unpkg.com/@solana/web3.js@latest/module.flow.js.
+Flow types are no longer supported in new releases. The last release with Flow support is v1.37.2 and its
+[Flow library definition](https://flow.org/en/docs/libdefs/) is provided at
+https://unpkg.com/@solana/web3.js@v1.37.2/module.flow.js.
 Download the file and add the following line under the [libs] section of your project's `.flowconfig` to
 activate it:
 

diff --git a/examples/get_account_info.js b/examples/get_account_info.js
diff --git a/examples/send_sol.js b/examples/send_sol.js
diff --git a/mocha.html b/mocha.html
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -20,9 +20,10 @@
     "access": "public"
   },
   "browser": {
-    "./lib/index.cjs.js": "./lib/index.browser.esm.js",
+    "./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",
@@ -33,46 +34,43 @@
   ],
   "files": [
     "/lib",
-    "/module.flow.js",
     "/src"
   ],
   "scripts": {
-    "build": "npm run clean; cross-env NODE_ENV=production rollup -c; npm run type:gen; npm run flow:gen; npm run flow:check",
-    "build:browser-test": "rollup -c test/rollup.config.js",
+    "build": "npm run clean; cross-env NODE_ENV=production rollup -c; npm run type:gen",
     "build:fixtures": "set -ex; ./test/fixtures/noop-program/build.sh",
     "clean": "rimraf ./coverage ./lib",
     "codecov": "set -ex; npm run test:cover; cat ./coverage/lcov.info | codecov",
     "dev": "cross-env NODE_ENV=development rollup -c",
     "doc": "set -ex; typedoc --treatWarningsAsErrors",
-    "flow:check": "flow check-contents < module.flow.js",
-    "flow:gen": "flowgen lib/index.d.ts -o module.flow.js",
     "type:gen": "./scripts/typegen.sh",
     "lint": "set -ex; npm run pretty; eslint . --ext .js,.ts",
     "lint:fix": "npm run pretty:fix && eslint . --fix --ext .js,.ts",
-    "ok": "run-s lint test doc",
+    "type:check": "tsc -p tsconfig.json --noEmit",
+    "ok": "run-s lint test doc type:check",
     "pretty": "prettier --check '{,{src,test}/**/}*.{j,t}s'",
     "pretty:fix": "prettier --write '{,{src,test}/**/}*.{j,t}s'",
     "re": "semantic-release --repository-url git@github.com:solana-labs/solana-web3.js.git",
-    "test": "mocha -r ts-node/register './test/**/*.test.ts'",
-    "test:cover": "TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' nyc --reporter=lcov mocha -r ts-node/register './test/**/*.test.ts'",
-    "test:browser": "TEST_LIVE=1 npm run build:browser-test && mocha-headless-chrome -f http://localhost:8080/mocha.html --timeout 180000",
-    "test:browser-with-server": "start-server-and-test 'http-server -p 8080' 8080 test:browser",
-    "test:browser-with-test-validator": "start-server-and-test 'solana-test-validator --reset --quiet' http://localhost:8899/health test:browser-with-server",
+    "test": "cross-env TS_NODE_COMPILER_OPTIONS='{ \"module\": \"commonjs\", \"target\": \"es2019\" }' ts-mocha --require esm './test/**/*.test.ts'",
+    "test:cover": "nyc --reporter=lcov npm run test",
     "test:live": "TEST_LIVE=1 npm run test",
     "test:live-with-test-validator": "start-server-and-test 'solana-test-validator --reset --quiet' http://localhost:8899/health test:live"
   },
   "dependencies": {
     "@babel/runtime": "^7.12.5",
     "@ethersproject/sha2": "^5.5.0",
-    "@solana/buffer-layout": "^3.0.0",
+    "@solana/buffer-layout": "^4.0.0",
+    "bigint-buffer": "^1.1.5",
     "bn.js": "^5.0.0",
-    "borsh": "^0.4.0",
+    "borsh": "^0.7.0",
     "bs58": "^4.0.1",
     "buffer": "6.0.1",
-    "cross-fetch": "^3.1.4",
+    "fast-stable-stringify": "^1.0.0",
     "jayson": "^3.4.4",
     "js-sha3": "^0.8.0",
-    "rpc-websockets": "^7.4.2",
+    "node-fetch": "2",
+    "react-native-url-polyfill": "^1.3.0",
+    "rpc-websockets": "^7.5.0",
     "secp256k1": "^4.0.2",
     "superstruct": "^0.14.2",
     "tweetnacl": "^1.0.0"
@@ -84,26 +82,28 @@
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-typescript": "^7.12.16",
     "@babel/register": "^7.12.13",
-    "@commitlint/config-conventional": "^14.1.0",
-    "@commitlint/travis-cli": "^14.1.0",
-    "@rollup/plugin-alias": "^3.1.2",
+    "@commitlint/config-conventional": "^17.0.2",
+    "@commitlint/travis-cli": "^17.0.0",
+    "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-babel": "^5.2.3",
-    "@rollup/plugin-commonjs": "^21.0.0",
+    "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-multi-entry": "^4.0.0",
     "@rollup/plugin-node-resolve": "^13.0.0",
-    "@rollup/plugin-replace": "^3.0.0",
-    "@solana/spl-token": "^0.1.2",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@solana/spl-token": "^0.2.0",
     "@types/bn.js": "^5.1.0",
     "@types/bs58": "^4.0.1",
     "@types/chai": "^4.2.15",
     "@types/chai-as-promised": "^7.1.3",
     "@types/express-serve-static-core": "^4.17.21",
     "@types/mocha": "^9.0.0",
     "@types/mz": "^2.7.3",
-    "@types/node": "^16.0.0",
+    "@types/node": "^17.0.24",
+    "@types/node-fetch": "2",
     "@types/secp256k1": "^4.0.1",
     "@types/sinon": "^10.0.0",
+    "@types/sinon-chai": "^3.2.8",
     "@typescript-eslint/eslint-plugin": "^4.14.2",
     "@typescript-eslint/parser": "^4.14.2",
     "chai": "^4.3.0",
@@ -112,29 +112,27 @@
     "cross-env": "7.0.3",
     "eslint": "^7.19.0",
     "eslint-config-prettier": "^8.0.0",
-    "eslint-plugin-import": "2.25.3",
-    "eslint-plugin-mocha": "^9.0.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-mocha": "^10.0.4",
     "eslint-plugin-prettier": "^4.0.0",
     "esm": "^3.2.25",
-    "flow-bin": "^0.150.0",
-    "flowgen": "^1.13.0",
     "http-server": "^14.0.0",
     "mocha": "^8.2.1",
-    "mocha-headless-chrome": "^3.1.0",
     "mockttp": "^2.0.1",
     "mz": "^2.7.0",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "prettier": "^2.3.0",
-    "puppeteer": "^11.0.0",
     "rimraf": "3.0.2",
-    "rollup": "2.60.0",
+    "rollup": "2.70.2",
     "rollup-plugin-dts": "^4.0.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "rollup-plugin-terser": "^7.0.2",
-    "semantic-release": "^18.0.0",
-    "sinon": "^12.0.0",
+    "semantic-release": "^19.0.3",
+    "sinon": "^13.0.2",
+    "sinon-chai": "^3.7.0",
     "start-server-and-test": "^1.12.0",
+    "ts-mocha": "^10.0.0",
     "ts-node": "^10.0.0",
     "tslib": "^2.1.0",
     "typedoc": "^0.22.2",

diff --git a/rollup.config.js b/rollup.config.js
@@ -1,6 +1,9 @@
+import alias from '@rollup/plugin-alias';
 import babel from '@rollup/plugin-babel';
 import commonjs from '@rollup/plugin-commonjs';
+import * as fs from 'fs';
 import json from '@rollup/plugin-json';
+import path from 'path';
 import nodeResolve from '@rollup/plugin-node-resolve';
 import replace from '@rollup/plugin-replace';
 import {terser} from 'rollup-plugin-terser';
@@ -9,12 +12,47 @@ const env = process.env.NODE_ENV;
 const extensions = ['.js', '.ts'];
 
 function generateConfig(configType, format) {
-  const browser = configType === 'browser';
+  const browser = configType === 'browser' || configType === 'react-native';
   const bundle = format === 'iife';
 
   const config = {
     input: 'src/index.ts',
     plugins: [
+      alias({
+        entries: [
+          {
+            find: /^\./, // Relative paths.
+            replacement: '.',
+            async customResolver(source, importer, options) {
+              const resolved = await this.resolve(source, importer, {
+                skipSelf: true,
+                ...options,
+              });
+              if (resolved == null) {
+                return;
+              }
+              const {id: resolvedId} = resolved;
+              const directory = path.dirname(resolvedId);
+              const moduleFilename = path.basename(resolvedId);
+              const forkPath = path.join(
+                directory,
+                '__forks__',
+                configType,
+                moduleFilename,
+              );
+              const hasForkCacheKey = `has_fork:${forkPath}`;
+              let hasFork = this.cache.get(hasForkCacheKey);
+              if (hasFork === undefined) {
+                hasFork = fs.existsSync(forkPath);
+                this.cache.set(hasForkCacheKey, hasFork);
+              }
+              if (hasFork) {
+                return forkPath;
+              }
+            },
+          },
+        ],
+      }),
       commonjs(),
       nodeResolve({
         browser,
@@ -33,32 +71,40 @@ function generateConfig(configType, format) {
         values: {
           'process.env.NODE_ENV': JSON.stringify(env),
           'process.env.BROWSER': JSON.stringify(browser),
+          'process.env.npm_package_version': JSON.stringify(
+            process.env.npm_package_version,
+          ),
         },
       }),
     ],
     onwarn: function (warning, rollupWarn) {
-      if (warning.code !== 'CIRCULAR_DEPENDENCY') {
-        rollupWarn(warning);
+      rollupWarn(warning);
+      if (warning.code === 'CIRCULAR_DEPENDENCY') {
+        throw new Error(
+          'Please eliminate the circular dependencies listed ' +
+            'above and retry the build',
+        );
       }
     },
     treeshake: {
       moduleSideEffects: false,
     },
   };
 
-  if (configType !== 'browser') {
+  if (!browser) {
     // Prevent dependencies from being bundled
     config.external = [
       /@babel\/runtime/,
       '@solana/buffer-layout',
+      'bigint-buffer',
       'bn.js',
       'borsh',
       'bs58',
       'buffer',
       'crypto-hash',
       'jayson/lib/client/browser',
       'js-sha3',
-      'cross-fetch',
+      'node-fetch',
       'rpc-websockets',
       'secp256k1',
       'superstruct',
@@ -68,20 +114,52 @@ function generateConfig(configType, format) {
 
   switch (configType) {
     case 'browser':
+    case 'react-native':
       switch (format) {
-        case 'esm': {
+        case 'iife': {
+          config.external = ['http', 'https', 'node-fetch'];
+
           config.output = [
             {
-              file: 'lib/index.browser.esm.js',
-              format: 'es',
+              file: 'lib/index.iife.js',
+              format: 'iife',
+              name: 'solanaWeb3',
               sourcemap: true,
             },
+            {
+              file: 'lib/index.iife.min.js',
+              format: 'iife',
+              name: 'solanaWeb3',
+              sourcemap: true,
+              plugins: [terser({mangle: false, compress: false})],
+            },
           ];
 
+          break;
+        }
+        default: {
+          config.output = [
+            {
+              file: `lib/index.${
+                configType === 'react-native' ? 'native' : 'browser.cjs'
+              }.js`,
+              format: 'cjs',
+              sourcemap: true,
+            },
+            configType === 'browser'
+              ? {
+                  file: 'lib/index.browser.esm.js',
+                  format: 'es',
+                  sourcemap: true,
+                }
+              : null,
+          ].filter(Boolean);
+
           // Prevent dependencies from being bundled
           config.external = [
             /@babel\/runtime/,
             '@solana/buffer-layout',
+            'bigint-buffer',
             'bn.js',
             'borsh',
             'bs58',
@@ -91,6 +169,8 @@ function generateConfig(configType, format) {
             'https',
             'jayson/lib/client/browser',
             'js-sha3',
+            'node-fetch',
+            'react-native-url-polyfill',
             'rpc-websockets',
             'secp256k1',
             'superstruct',
@@ -99,29 +179,6 @@ function generateConfig(configType, format) {
 
           break;
         }
-        case 'iife': {
-          config.external = ['http', 'https'];
-
-          config.output = [
-            {
-              file: 'lib/index.iife.js',
-              format: 'iife',
-              name: 'solanaWeb3',
-              sourcemap: true,
-            },
-            {
-              file: 'lib/index.iife.min.js',
-              format: 'iife',
-              name: 'solanaWeb3',
-              sourcemap: true,
-              plugins: [terser({mangle: false, compress: false})],
-            },
-          ];
-
-          break;
-        }
-        default:
-          throw new Error(`Unknown format: ${format}`);
       }
 
       // TODO: Find a workaround to avoid resolving the following JSON file:
@@ -152,6 +209,7 @@ function generateConfig(configType, format) {
 
 export default [
   generateConfig('node'),
-  generateConfig('browser', 'esm'),
+  generateConfig('browser'),
   generateConfig('browser', 'iife'),
+  generateConfig('react-native'),
 ];
diff --git a/scripts/typegen.sh b/scripts/typegen.sh
@@ -7,13 +7,16 @@ npx tsc -p tsconfig.d.json -d
 npx rollup -c rollup.config.types.js
 
 # Replace export with closing brace for module declaration
-sed -i '$s/export {.*};/}/' lib/index.d.ts
+sed -i.bak '$s/export {.*};/}/' lib/index.d.ts
 
 # Replace declare's with export's
-sed -i 's/declare/export/g' lib/index.d.ts
+sed -i.bak 's/declare/export/g' lib/index.d.ts
 
 # Prepend declare module line
-sed -i '2s;^;declare module "@solana/web3.js" {\n;' lib/index.d.ts
+sed -i.bak '2s;^;declare module "@solana/web3.js" {\n;' lib/index.d.ts
+
+# Remove backup file from `sed` above
+rm lib/index.d.ts.bak
 
 # Run prettier
 npx prettier --write lib/index.d.ts

diff --git a/src/__forks__/browser/fetch-impl.ts b/src/__forks__/browser/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;
diff --git a/src/__forks__/react-native/fetch-impl.ts b/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;
diff --git a/src/address-lookup-table-program.ts b/src/address-lookup-table-program.ts
diff --git a/src/compute-budget.ts b/src/compute-budget.ts
@@ -0,0 +1,278 @@
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
+import {PublicKey} from './publickey';
+import {TransactionInstruction} from './transaction';
+import {u64} from './util/bigint';
+
+/**
+ * Compute Budget Instruction class
+ */
+export class ComputeBudgetInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Decode a compute budget instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(
+    instruction: TransactionInstruction,
+  ): ComputeBudgetInstructionType {
+    this.checkProgramId(instruction.programId);
+
+    const instructionTypeLayout = BufferLayout.u8('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+
+    let type: ComputeBudgetInstructionType | undefined;
+    for (const [ixType, layout] of Object.entries(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS,
+    )) {
+      if (layout.index == typeIndex) {
+        type = ixType as ComputeBudgetInstructionType;
+        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: TransactionInstruction,
+  ): RequestUnitsParams {
+    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: TransactionInstruction,
+  ): RequestHeapFrameParams {
+    this.checkProgramId(instruction.programId);
+    const {bytes} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame,
+      instruction.data,
+    );
+    return {bytes};
+  }
+
+  /**
+   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+   */
+  static decodeSetComputeUnitLimit(
+    instruction: TransactionInstruction,
+  ): SetComputeUnitLimitParams {
+    this.checkProgramId(instruction.programId);
+    const {units} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit,
+      instruction.data,
+    );
+    return {units};
+  }
+
+  /**
+   * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+   */
+  static decodeSetComputeUnitPrice(
+    instruction: TransactionInstruction,
+  ): SetComputeUnitPriceParams {
+    this.checkProgramId(instruction.programId);
+    const {microLamports} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice,
+      instruction.data,
+    );
+    return {microLamports};
+  }
+
+  /**
+   * @internal
+   */
+  static checkProgramId(programId: PublicKey) {
+    if (!programId.equals(ComputeBudgetProgram.programId)) {
+      throw new Error(
+        'invalid instruction; programId is not ComputeBudgetProgram',
+      );
+    }
+  }
+}
+
+/**
+ * An enumeration of valid ComputeBudgetInstructionType's
+ */
+export type ComputeBudgetInstructionType =
+  // FIXME
+  // It would be preferable for this type to be `keyof ComputeBudgetInstructionInputData`
+  // but Typedoc does not transpile `keyof` expressions.
+  // See https://github.com/TypeStrong/typedoc/issues/1894
+  | 'RequestUnits'
+  | 'RequestHeapFrame'
+  | 'SetComputeUnitLimit'
+  | 'SetComputeUnitPrice';
+
+type ComputeBudgetInstructionInputData = {
+  RequestUnits: IInstructionInputData & Readonly<RequestUnitsParams>;
+  RequestHeapFrame: IInstructionInputData & Readonly<RequestHeapFrameParams>;
+  SetComputeUnitLimit: IInstructionInputData &
+    Readonly<SetComputeUnitLimitParams>;
+  SetComputeUnitPrice: IInstructionInputData &
+    Readonly<SetComputeUnitPriceParams>;
+};
+
+/**
+ * Request units instruction params
+ */
+export interface RequestUnitsParams {
+  /** Units to request for transaction-wide compute */
+  units: number;
+  /** Prioritization fee lamports */
+  additionalFee: number;
+}
+
+/**
+ * Request heap frame instruction params
+ */
+export type RequestHeapFrameParams = {
+  /** Requested transaction-wide program heap size in bytes. Must be multiple of 1024. Applies to each program, including CPIs. */
+  bytes: number;
+};
+
+/**
+ * Set compute unit limit instruction params
+ */
+export interface SetComputeUnitLimitParams {
+  /** Transaction-wide compute unit limit */
+  units: number;
+}
+
+/**
+ * Set compute unit price instruction params
+ */
+export interface SetComputeUnitPriceParams {
+  /** Transaction compute unit price used for prioritization fees */
+  microLamports: number | bigint;
+}
+
+/**
+ * An enumeration of valid ComputeBudget InstructionType's
+ * @internal
+ */
+export const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in ComputeBudgetInstructionType]: InstructionType<
+    ComputeBudgetInstructionInputData[Instruction]
+  >;
+}>({
+  RequestUnits: {
+    index: 0,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['RequestUnits']
+    >([
+      BufferLayout.u8('instruction'),
+      BufferLayout.u32('units'),
+      BufferLayout.u32('additionalFee'),
+    ]),
+  },
+  RequestHeapFrame: {
+    index: 1,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['RequestHeapFrame']
+    >([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')]),
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['SetComputeUnitLimit']
+    >([BufferLayout.u8('instruction'), BufferLayout.u32('units')]),
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['SetComputeUnitPrice']
+    >([BufferLayout.u8('instruction'), u64('microLamports')]),
+  },
+});
+
+/**
+ * Factory class for transaction instructions to interact with the Compute Budget program
+ */
+export class ComputeBudgetProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Public key that identifies the Compute Budget program
+   */
+  static programId: PublicKey = new PublicKey(
+    'ComputeBudget111111111111111111111111111111',
+  );
+
+  static requestUnits(params: RequestUnitsParams): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+
+  static requestHeapFrame(
+    params: RequestHeapFrameParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+
+  static setComputeUnitLimit(
+    params: SetComputeUnitLimitParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+
+  static setComputeUnitPrice(
+    params: SetComputeUnitPriceParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+    const data = encodeData(type, {
+      microLamports: BigInt(params.microLamports),
+    });
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+}
diff --git a/src/connection.ts b/src/connection.ts
diff --git a/src/ed25519-program.ts b/src/ed25519-program.ts
@@ -30,7 +30,19 @@ export type CreateEd25519InstructionWithPrivateKeyParams = {
   instructionIndex?: number;
 };
 
-const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([
+const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct<
+  Readonly<{
+    messageDataOffset: number;
+    messageDataSize: number;
+    messageInstructionIndex: number;
+    numSignatures: number;
+    padding: number;
+    publicKeyInstructionIndex: number;
+    publicKeyOffset: number;
+    signatureInstructionIndex: number;
+    signatureOffset: number;
+  }>
+>([
   BufferLayout.u8('numSignatures'),
   BufferLayout.u8('padding'),
   BufferLayout.u16('signatureOffset'),
@@ -82,17 +94,22 @@ export class Ed25519Program {
 
     const instructionData = Buffer.alloc(messageDataOffset + message.length);
 
+    const index =
+      instructionIndex == null
+        ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.
+        : instructionIndex;
+
     ED25519_INSTRUCTION_LAYOUT.encode(
       {
         numSignatures,
         padding: 0,
         signatureOffset,
-        signatureInstructionIndex: instructionIndex,
+        signatureInstructionIndex: index,
         publicKeyOffset,
-        publicKeyInstructionIndex: instructionIndex,
+        publicKeyInstructionIndex: index,
         messageDataOffset,
         messageDataSize: message.length,
-        messageInstructionIndex: instructionIndex,
+        messageInstructionIndex: index,
       },
       instructionData,
     );

diff --git a/src/errors.ts b/src/errors.ts
@@ -7,3 +7,44 @@ export class SendTransactionError extends Error {
     this.logs = logs;
   }
 }
+
+// Keep in sync with client/src/rpc_custom_errors.rs
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+export const SolanaJSONRPCErrorCode = {
+  JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,
+  JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,
+  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,
+  JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,
+  JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,
+  JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,
+  JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,
+  JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,
+  JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,
+  JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,
+  JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,
+  JSON_RPC_SCAN_ERROR: -32012,
+  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,
+  JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,
+  JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,
+  JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016,
+} as const;
+export type SolanaJSONRPCErrorCodeEnum =
+  typeof SolanaJSONRPCErrorCode[keyof typeof SolanaJSONRPCErrorCode];
+
+export class SolanaJSONRPCError extends Error {
+  code: SolanaJSONRPCErrorCodeEnum | unknown;
+  data?: any;
+  constructor(
+    {
+      code,
+      message,
+      data,
+    }: Readonly<{code: unknown; message: string; data?: any}>,
+    customMessage?: string,
+  ) {
+    super(customMessage != null ? `${customMessage}: ${message}` : message);
+    this.code = code;
+    this.data = data;
+    this.name = 'SolanaJSONRPCError';
+  }
+}
diff --git a/src/fetch-impl.ts b/src/fetch-impl.ts
@@ -0,0 +1,13 @@
+import * as nodeFetch from 'node-fetch';
+
+export * from 'node-fetch';
+export default async function (
+  input: nodeFetch.RequestInfo,
+  init?: nodeFetch.RequestInit,
+): Promise<nodeFetch.Response> {
+  const processedInput =
+    typeof input === 'string' && input.slice(0, 2) === '//'
+      ? 'https:' + input
+      : input;
+  return await nodeFetch.default(processedInput, init);
+}
diff --git a/src/index.ts b/src/index.ts
@@ -1,7 +1,9 @@
 export * from './account';
+export * from './address-lookup-table-program';
 export * from './blockhash';
 export * from './bpf-loader-deprecated';
 export * from './bpf-loader';
+export * from './compute-budget';
 export * from './connection';
 export * from './epoch-schedule';
 export * from './ed25519-program';
@@ -15,13 +17,16 @@ export * from './stake-program';
 export * from './system-program';
 export * from './secp256k1-program';
 export * from './transaction';
+export * from './transaction-constants';
 export * from './validator-info';
 export * from './vote-account';
+export * from './vote-program';
 export * from './sysvar';
 export * from './errors';
 export * from './util/borsh-schema';
 export * from './util/send-and-confirm-transaction';
 export * from './util/send-and-confirm-raw-transaction';
+export * from './util/tx-expiry-custom-errors';
 export * from './util/cluster';
 
 /**

diff --git a/src/instruction.ts b/src/instruction.ts
@@ -3,21 +3,28 @@ import * as BufferLayout from '@solana/buffer-layout';
 
 import * as Layout from './layout';
 
+export interface IInstructionInputData {
+  readonly instruction: number;
+}
+
 /**
  * @internal
  */
-export type InstructionType = {
+export type InstructionType<TInputData extends IInstructionInputData> = {
   /** The Instruction index (from solana upstream program) */
   index: number;
   /** The BufferLayout to use to build data */
-  layout: BufferLayout.Layout;
+  layout: BufferLayout.Layout<TInputData>;
 };
 
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
  */
-export function encodeData(type: InstructionType, fields?: any): Buffer {
+export function encodeData<TInputData extends IInstructionInputData>(
+  type: InstructionType<TInputData>,
+  fields?: any,
+): Buffer {
   const allocLength =
     type.layout.span >= 0 ? type.layout.span : Layout.getAlloc(type, fields);
   const data = Buffer.alloc(allocLength);
@@ -30,8 +37,11 @@ export function encodeData(type: InstructionType, fields?: any): Buffer {
  * Decode instruction data buffer using an InstructionType
  * @internal
  */
-export function decodeData(type: InstructionType, buffer: Buffer): any {
-  let data;
+export function decodeData<TInputData extends IInstructionInputData>(
+  type: InstructionType<TInputData>,
+  buffer: Buffer,
+): TInputData {
+  let data: TInputData;
   try {
     data = type.layout.decode(buffer);
   } catch (err) {

diff --git a/src/layout.ts b/src/layout.ts
@@ -4,24 +4,47 @@ import * as BufferLayout from '@solana/buffer-layout';
 /**
  * Layout for a public key
  */
-export const publicKey = (
-  property: string = 'publicKey',
-): BufferLayout.Layout => {
+export const publicKey = (property: string = 'publicKey') => {
   return BufferLayout.blob(32, property);
 };
 
 /**
  * Layout for a 64bit unsigned value
  */
-export const uint64 = (property: string = 'uint64'): BufferLayout.Layout => {
+export const uint64 = (property: string = 'uint64') => {
   return BufferLayout.blob(8, property);
 };
 
+interface IRustStringShim
+  extends Omit<
+    BufferLayout.Structure<
+      Readonly<{
+        length: number;
+        lengthPadding: number;
+        chars: Uint8Array;
+      }>
+    >,
+    'decode' | 'encode' | 'replicate'
+  > {
+  alloc: (str: string) => number;
+  decode: (b: Uint8Array, offset?: number) => string;
+  encode: (str: string, b: Uint8Array, offset?: number) => number;
+  replicate: (property: string) => this;
+}
+
 /**
  * Layout for a Rust String type
  */
-export const rustString = (property: string = 'string') => {
-  const rsl = BufferLayout.struct(
+export const rustString = (
+  property: string = 'string',
+): BufferLayout.Layout<string> => {
+  const rsl = BufferLayout.struct<
+    Readonly<{
+      length?: number;
+      lengthPadding?: number;
+      chars: Uint8Array;
+    }>
+  >(
     [
       BufferLayout.u32('length'),
       BufferLayout.u32('lengthPadding'),
@@ -32,44 +55,54 @@ export const rustString = (property: string = 'string') => {
   const _decode = rsl.decode.bind(rsl);
   const _encode = rsl.encode.bind(rsl);
 
-  rsl.decode = (buffer: any, offset: any) => {
-    const data = _decode(buffer, offset);
-    return data['chars'].toString('utf8');
+  const rslShim = rsl as unknown as IRustStringShim;
+
+  rslShim.decode = (b: Uint8Array, offset?: number) => {
+    const data = _decode(b, offset);
+    return data['chars'].toString();
   };
 
-  rsl.encode = (str: any, buffer: any, offset: any) => {
+  rslShim.encode = (str: string, b: Uint8Array, offset?: number) => {
     const data = {
       chars: Buffer.from(str, 'utf8'),
     };
-    return _encode(data, buffer, offset);
+    return _encode(data, b, offset);
   };
 
-  (rsl as any).alloc = (str: any) => {
+  rslShim.alloc = (str: string) => {
     return (
       BufferLayout.u32().span +
       BufferLayout.u32().span +
       Buffer.from(str, 'utf8').length
     );
   };
 
-  return rsl;
+  return rslShim;
 };
 
 /**
  * Layout for an Authorized object
  */
 export const authorized = (property: string = 'authorized') => {
-  return BufferLayout.struct(
-    [publicKey('staker'), publicKey('withdrawer')],
-    property,
-  );
+  return BufferLayout.struct<
+    Readonly<{
+      staker: Uint8Array;
+      withdrawer: Uint8Array;
+    }>
+  >([publicKey('staker'), publicKey('withdrawer')], property);
 };
 
 /**
  * Layout for a Lockup object
  */
 export const lockup = (property: string = 'lockup') => {
-  return BufferLayout.struct(
+  return BufferLayout.struct<
+    Readonly<{
+      custodian: Uint8Array;
+      epoch: number;
+      unixTimestamp: number;
+    }>
+  >(
     [
       BufferLayout.ns64('unixTimestamp'),
       BufferLayout.ns64('epoch'),
@@ -79,14 +112,48 @@ export const lockup = (property: string = 'lockup') => {
   );
 };
 
+/**
+ *  Layout for a VoteInit object
+ */
+export const voteInit = (property: string = 'voteInit') => {
+  return BufferLayout.struct<
+    Readonly<{
+      authorizedVoter: Uint8Array;
+      authorizedWithdrawer: Uint8Array;
+      commission: number;
+      nodePubkey: Uint8Array;
+    }>
+  >(
+    [
+      publicKey('nodePubkey'),
+      publicKey('authorizedVoter'),
+      publicKey('authorizedWithdrawer'),
+      BufferLayout.u8('commission'),
+    ],
+    property,
+  );
+};
+
 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;
 }
diff --git a/src/loader.ts b/src/loader.ts
@@ -2,13 +2,15 @@ import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
 import {PublicKey} from './publickey';
-import {Transaction, PACKET_DATA_SIZE} from './transaction';
+import {Transaction} from './transaction';
 import {SYSVAR_RENT_PUBKEY} from './sysvar';
 import {sendAndConfirmTransaction} from './util/send-and-confirm-transaction';
 import {sleep} from './util/sleep';
 import type {Connection} from './connection';
 import type {Signer} from './keypair';
 import {SystemProgram} from './system-program';
+import {IInstructionInputData} from './instruction';
+import {PACKET_DATA_SIZE} from './transaction-constants';
 
 // Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
 // rest of the Transaction fields
@@ -137,7 +139,15 @@ export class Loader {
       }
     }
 
-    const dataLayout = BufferLayout.struct([
+    const dataLayout = BufferLayout.struct<
+      Readonly<{
+        bytes: number[];
+        bytesLength: number;
+        bytesLengthPadding: number;
+        instruction: number;
+        offset: number;
+      }>
+    >([
       BufferLayout.u32('instruction'),
       BufferLayout.u32('offset'),
       BufferLayout.u32('bytesLength'),
@@ -160,7 +170,9 @@ export class Loader {
         {
           instruction: 0, // Load instruction
           offset,
-          bytes,
+          bytes: bytes as number[],
+          bytesLength: 0,
+          bytesLengthPadding: 0,
         },
         data,
       );
@@ -189,7 +201,9 @@ export class Loader {
 
     // Finalize the account loaded with program data for execution
     {
-      const dataLayout = BufferLayout.struct([BufferLayout.u32('instruction')]);
+      const dataLayout = BufferLayout.struct<IInstructionInputData>([
+        BufferLayout.u32('instruction'),
+      ]);
 
       const data = Buffer.alloc(dataLayout.span);
       dataLayout.encode(

diff --git a/src/message.ts b/src/message.ts
@@ -5,7 +5,7 @@ import * as BufferLayout from '@solana/buffer-layout';
 import {PublicKey} from './publickey';
 import type {Blockhash} from './blockhash';
 import * as Layout from './layout';
-import {PACKET_DATA_SIZE} from './transaction';
+import {PACKET_DATA_SIZE} from './transaction-constants';
 import * as shortvec from './util/shortvec-encoding';
 import {toBuffer} from './util/to-buffer';
 
@@ -118,7 +118,7 @@ export class Message {
 
     const instructions = this.instructions.map(instruction => {
       const {accounts, programIdIndex} = instruction;
-      const data = bs58.decode(instruction.data);
+      const data = Array.from(bs58.decode(instruction.data));
 
       let keyIndicesCount: number[] = [];
       shortvec.encodeLength(keyIndicesCount, accounts.length);
@@ -129,7 +129,7 @@ export class Message {
       return {
         programIdIndex,
         keyIndicesCount: Buffer.from(keyIndicesCount),
-        keyIndices: Buffer.from(accounts),
+        keyIndices: accounts,
         dataLength: Buffer.from(dataCount),
         data,
       };
@@ -142,7 +142,15 @@ export class Message {
     let instructionBufferLength = instructionCount.length;
 
     instructions.forEach(instruction => {
-      const instructionLayout = BufferLayout.struct([
+      const instructionLayout = BufferLayout.struct<
+        Readonly<{
+          data: number[];
+          dataLength: Uint8Array;
+          keyIndices: number[];
+          keyIndicesCount: Uint8Array;
+          programIdIndex: number;
+        }>
+      >([
         BufferLayout.u8('programIdIndex'),
 
         BufferLayout.blob(
@@ -170,7 +178,16 @@ export class Message {
     });
     instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);
 
-    const signDataLayout = BufferLayout.struct([
+    const signDataLayout = BufferLayout.struct<
+      Readonly<{
+        keyCount: Uint8Array;
+        keys: Uint8Array[];
+        numReadonlySignedAccounts: Uint8Array;
+        numReadonlyUnsignedAccounts: Uint8Array;
+        numRequiredSignatures: Uint8Array;
+        recentBlockhash: Uint8Array;
+      }>
+    >([
       BufferLayout.blob(1, 'numRequiredSignatures'),
       BufferLayout.blob(1, 'numReadonlySignedAccounts'),
       BufferLayout.blob(1, 'numReadonlyUnsignedAccounts'),

diff --git a/src/nonce-account.ts b/src/nonce-account.ts
@@ -13,12 +13,25 @@ import {toBuffer} from './util/to-buffer';
  *
  * @internal
  */
-const NonceAccountLayout = BufferLayout.struct([
+const NonceAccountLayout = BufferLayout.struct<
+  Readonly<{
+    authorizedPubkey: Uint8Array;
+    feeCalculator: Readonly<{
+      lamportsPerSignature: number;
+    }>;
+    nonce: Uint8Array;
+    state: number;
+    version: number;
+  }>
+>([
   BufferLayout.u32('version'),
   BufferLayout.u32('state'),
   Layout.publicKey('authorizedPubkey'),
   Layout.publicKey('nonce'),
-  BufferLayout.struct([FeeCalculatorLayout], 'feeCalculator'),
+  BufferLayout.struct<Readonly<{lamportsPerSignature: number}>>(
+    [FeeCalculatorLayout],
+    'feeCalculator',
+  ),
 ]);
 
 export const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;

diff --git a/src/publickey.ts b/src/publickey.ts
@@ -87,6 +87,10 @@ export class PublicKey extends Struct {
     return bs58.encode(this.toBytes());
   }
 
+  toJSON(): string {
+    return this.toBase58();
+  }
+
   /**
    * Return the byte array representation of the public key
    */
@@ -139,10 +143,10 @@ export class PublicKey extends Struct {
    * Derive a program address from seeds and a program ID.
    */
   /* eslint-disable require-await */
-  static async createProgramAddress(
+  static createProgramAddressSync(
     seeds: Array<Buffer | Uint8Array>,
     programId: PublicKey,
-  ): Promise<PublicKey> {
+  ): PublicKey {
     let buffer = Buffer.alloc(0);
     seeds.forEach(function (seed) {
       if (seed.length > MAX_SEED_LENGTH) {
@@ -163,23 +167,35 @@ export class PublicKey extends Struct {
     return new PublicKey(publicKeyBytes);
   }
 
+  /**
+   * Async version of createProgramAddressSync
+   * For backwards compatibility
+   */
+  /* eslint-disable require-await */
+  static async createProgramAddress(
+    seeds: Array<Buffer | Uint8Array>,
+    programId: PublicKey,
+  ): Promise<PublicKey> {
+    return this.createProgramAddressSync(seeds, programId);
+  }
+
   /**
    * Find a valid program address
    *
    * Valid program addresses must fall off the ed25519 curve.  This function
    * iterates a nonce until it finds one that when combined with the seeds
    * results in a valid program address.
    */
-  static async findProgramAddress(
+  static findProgramAddressSync(
     seeds: Array<Buffer | Uint8Array>,
     programId: PublicKey,
-  ): Promise<[PublicKey, number]> {
+  ): [PublicKey, number] {
     let nonce = 255;
     let address;
     while (nonce != 0) {
       try {
         const seedsWithNonce = seeds.concat(Buffer.from([nonce]));
-        address = await this.createProgramAddress(seedsWithNonce, programId);
+        address = this.createProgramAddressSync(seedsWithNonce, programId);
       } catch (err) {
         if (err instanceof TypeError) {
           throw err;
@@ -192,11 +208,23 @@ export 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: Array<Buffer | Uint8Array>,
+    programId: PublicKey,
+  ): Promise<[PublicKey, number]> {
+    return this.findProgramAddressSync(seeds, programId);
+  }
+
   /**
    * Check that a pubkey is on the ed25519 curve.
    */
-  static isOnCurve(pubkey: Uint8Array): boolean {
-    return is_on_curve(pubkey) == 1;
+  static isOnCurve(pubkeyData: PublicKeyInitData): boolean {
+    const pubkey = new PublicKey(pubkeyData);
+    return is_on_curve(pubkey.toBytes()) == 1;
   }
 }
 

diff --git a/src/secp256k1-program.ts b/src/secp256k1-program.ts
@@ -46,7 +46,21 @@ export type CreateSecp256k1InstructionWithPrivateKeyParams = {
   instructionIndex?: number;
 };
 
-const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([
+const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct<
+  Readonly<{
+    ethAddress: Uint8Array;
+    ethAddressInstructionIndex: number;
+    ethAddressOffset: number;
+    messageDataOffset: number;
+    messageDataSize: number;
+    messageInstructionIndex: number;
+    numSignatures: number;
+    recoveryId: number;
+    signature: Uint8Array;
+    signatureInstructionIndex: number;
+    signatureOffset: number;
+  }>
+>([
   BufferLayout.u8('numSignatures'),
   BufferLayout.u16('signatureOffset'),
   BufferLayout.u8('signatureInstructionIndex'),

diff --git a/src/stake-program.ts b/src/stake-program.ts
@@ -1,6 +1,11 @@
 import * as BufferLayout from '@solana/buffer-layout';
 
-import {encodeData, decodeData, InstructionType} from './instruction';
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
 import * as Layout from './layout';
 import {PublicKey} from './publickey';
 import {SystemProgram} from './system-program';
@@ -40,6 +45,11 @@ export class Authorized {
   }
 }
 
+type AuthorizedRaw = Readonly<{
+  staker: Uint8Array;
+  withdrawer: Uint8Array;
+}>;
+
 /**
  * Stake account lockup info
  */
@@ -66,6 +76,12 @@ export class Lockup {
   static default: Lockup = new Lockup(0, 0, PublicKey.default);
 }
 
+type LockupRaw = Readonly<{
+  custodian: Uint8Array;
+  epoch: number;
+  unixTimestamp: number;
+}>;
+
 /**
  * Create stake account transaction params
  */
@@ -147,6 +163,18 @@ export type SplitStakeParams = {
   lamports: number;
 };
 
+/**
+ * Split with seed transaction params
+ */
+export type SplitStakeWithSeedParams = {
+  stakePubkey: PublicKey;
+  authorizedPubkey: PublicKey;
+  splitStakePubkey: PublicKey;
+  basePubkey: PublicKey;
+  seed: string;
+  lamports: number;
+};
+
 /**
  * Withdraw stake instruction params
  */
@@ -417,73 +445,119 @@ export class StakeInstruction {
  * An enumeration of valid StakeInstructionType's
  */
 export type StakeInstructionType =
-  | 'AuthorizeWithSeed'
+  // FIXME
+  // It would be preferable for this type to be `keyof StakeInstructionInputData`
+  // but Typedoc does not transpile `keyof` expressions.
+  // See https://github.com/TypeStrong/typedoc/issues/1894
   | 'Authorize'
+  | 'AuthorizeWithSeed'
   | 'Deactivate'
   | 'Delegate'
   | 'Initialize'
+  | 'Merge'
   | 'Split'
-  | 'Withdraw'
-  | 'Merge';
+  | 'Withdraw';
+
+type StakeInstructionInputData = {
+  Authorize: IInstructionInputData &
+    Readonly<{
+      newAuthorized: Uint8Array;
+      stakeAuthorizationType: number;
+    }>;
+  AuthorizeWithSeed: IInstructionInputData &
+    Readonly<{
+      authorityOwner: Uint8Array;
+      authoritySeed: string;
+      instruction: number;
+      newAuthorized: Uint8Array;
+      stakeAuthorizationType: number;
+    }>;
+  Deactivate: IInstructionInputData;
+  Delegate: IInstructionInputData;
+  Initialize: IInstructionInputData &
+    Readonly<{
+      authorized: AuthorizedRaw;
+      lockup: LockupRaw;
+    }>;
+  Merge: IInstructionInputData;
+  Split: IInstructionInputData &
+    Readonly<{
+      lamports: number;
+    }>;
+  Withdraw: IInstructionInputData &
+    Readonly<{
+      lamports: number;
+    }>;
+};
 
 /**
  * An enumeration of valid stake InstructionType's
  * @internal
  */
-export const STAKE_INSTRUCTION_LAYOUTS: {
-  [type in StakeInstructionType]: InstructionType;
-} = Object.freeze({
+export const STAKE_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in StakeInstructionType]: InstructionType<
+    StakeInstructionInputData[Instruction]
+  >;
+}>({
   Initialize: {
     index: 0,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Initialize']>([
       BufferLayout.u32('instruction'),
       Layout.authorized(),
       Layout.lockup(),
     ]),
   },
   Authorize: {
     index: 1,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Authorize']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('newAuthorized'),
       BufferLayout.u32('stakeAuthorizationType'),
     ]),
   },
   Delegate: {
     index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Delegate']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   Split: {
     index: 3,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Split']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
     ]),
   },
   Withdraw: {
     index: 4,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<StakeInstructionInputData['Withdraw']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
     ]),
   },
   Deactivate: {
     index: 5,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Deactivate']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   Merge: {
     index: 7,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<StakeInstructionInputData['Merge']>([
+      BufferLayout.u32('instruction'),
+    ]),
   },
   AuthorizeWithSeed: {
     index: 8,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('newAuthorized'),
-      BufferLayout.u32('stakeAuthorizationType'),
-      Layout.rustString('authoritySeed'),
-      Layout.publicKey('authorityOwner'),
-    ]),
+    layout: BufferLayout.struct<StakeInstructionInputData['AuthorizeWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        Layout.publicKey('newAuthorized'),
+        BufferLayout.u32('stakeAuthorizationType'),
+        Layout.rustString('authoritySeed'),
+        Layout.publicKey('authorityOwner'),
+      ],
+    ),
   },
 });
 
@@ -527,8 +601,8 @@ export class StakeProgram {
    * Max space of a Stake account
    *
    * This is generated from the solana-stake-program StakeState struct as
-   * `std::mem::size_of::<StakeState>()`:
-   * https://docs.rs/solana-stake-program/1.4.4/solana_stake_program/stake_state/enum.StakeState.html
+   * `StakeState::size_of()`:
+   * https://docs.rs/solana-stake-program/latest/solana_stake_program/stake_state/enum.StakeState.html
    */
   static space: number = 200;
 
@@ -706,25 +780,13 @@ export class StakeProgram {
   }
 
   /**
-   * Generate a Transaction that splits Stake tokens into another stake account
+   * @internal
    */
-  static split(params: SplitStakeParams): Transaction {
+  static splitInstruction(params: SplitStakeParams): TransactionInstruction {
     const {stakePubkey, authorizedPubkey, splitStakePubkey, lamports} = params;
-
-    const transaction = new Transaction();
-    transaction.add(
-      SystemProgram.createAccount({
-        fromPubkey: authorizedPubkey,
-        newAccountPubkey: splitStakePubkey,
-        lamports: 0,
-        space: this.space,
-        programId: this.programId,
-      }),
-    );
     const type = STAKE_INSTRUCTION_LAYOUTS.Split;
     const data = encodeData(type, {lamports});
-
-    return transaction.add({
+    return new TransactionInstruction({
       keys: [
         {pubkey: stakePubkey, isSigner: false, isWritable: true},
         {pubkey: splitStakePubkey, isSigner: false, isWritable: true},
@@ -735,6 +797,56 @@ export class StakeProgram {
     });
   }
 
+  /**
+   * Generate a Transaction that splits Stake tokens into another stake account
+   */
+  static split(params: SplitStakeParams): Transaction {
+    const transaction = new Transaction();
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: params.authorizedPubkey,
+        newAccountPubkey: params.splitStakePubkey,
+        lamports: 0,
+        space: this.space,
+        programId: this.programId,
+      }),
+    );
+    return transaction.add(this.splitInstruction(params));
+  }
+
+  /**
+   * Generate a Transaction that splits Stake tokens into another account
+   * derived from a base public key and seed
+   */
+  static splitWithSeed(params: SplitStakeWithSeedParams): Transaction {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      basePubkey,
+      seed,
+      lamports,
+    } = params;
+    const transaction = new Transaction();
+    transaction.add(
+      SystemProgram.allocate({
+        accountPubkey: splitStakePubkey,
+        basePubkey,
+        seed,
+        space: this.space,
+        programId: this.programId,
+      }),
+    );
+    return transaction.add(
+      this.splitInstruction({
+        stakePubkey,
+        authorizedPubkey,
+        splitStakePubkey,
+        lamports,
+      }),
+    );
+  }
+
   /**
    * Generate a Transaction that merges Stake accounts.
    */

diff --git a/src/system-program.ts b/src/system-program.ts
@@ -1,12 +1,18 @@
 import * as BufferLayout from '@solana/buffer-layout';
 
-import {encodeData, decodeData, InstructionType} from './instruction';
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
 import * as Layout from './layout';
 import {NONCE_ACCOUNT_LENGTH} from './nonce-account';
 import {PublicKey} from './publickey';
 import {SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY} from './sysvar';
 import {Transaction, TransactionInstruction} from './transaction';
 import {toBuffer} from './util/to-buffer';
+import {u64} from './util/bigint';
 
 /**
  * Create account system transaction params
@@ -33,7 +39,7 @@ export type TransferParams = {
   /** Account that will receive transferred lamports */
   toPubkey: PublicKey;
   /** Amount of lamports to transfer */
-  lamports: number;
+  lamports: number | bigint;
 };
 
 /**
@@ -195,7 +201,33 @@ export type TransferWithSeedParams = {
   /** Account that will receive transferred lamports */
   toPubkey: PublicKey;
   /** Amount of lamports to transfer */
-  lamports: number;
+  lamports: number | bigint;
+  /** Seed to use to derive the funding account address */
+  seed: string;
+  /** Program id to use to derive the funding account address */
+  programId: PublicKey;
+};
+
+/** Decoded transfer system transaction instruction */
+export type DecodedTransferInstruction = {
+  /** Account that will transfer lamports */
+  fromPubkey: PublicKey;
+  /** Account that will receive transferred lamports */
+  toPubkey: PublicKey;
+  /** Amount of lamports to transfer */
+  lamports: bigint;
+};
+
+/** Decoded transferWithSeed system transaction instruction */
+export type DecodedTransferWithSeedInstruction = {
+  /** Account that will transfer lamports */
+  fromPubkey: PublicKey;
+  /** Base public key to use to derive the funding account address */
+  basePubkey: PublicKey;
+  /** Account that will receive transferred lamports */
+  toPubkey: PublicKey;
+  /** Amount of lamports to transfer */
+  lamports: bigint;
   /** Seed to use to derive the funding account address */
   seed: string;
   /** Program id to use to derive the funding account address */
@@ -263,7 +295,9 @@ export class SystemInstruction {
   /**
    * Decode a transfer system instruction and retrieve the instruction params.
    */
-  static decodeTransfer(instruction: TransactionInstruction): TransferParams {
+  static decodeTransfer(
+    instruction: TransactionInstruction,
+  ): DecodedTransferInstruction {
     this.checkProgramId(instruction.programId);
     this.checkKeyLength(instruction.keys, 2);
 
@@ -284,7 +318,7 @@ export class SystemInstruction {
    */
   static decodeTransferWithSeed(
     instruction: TransactionInstruction,
-  ): TransferWithSeedParams {
+  ): DecodedTransferWithSeedInstruction {
     this.checkProgramId(instruction.programId);
     this.checkKeyLength(instruction.keys, 3);
 
@@ -517,6 +551,10 @@ export class SystemInstruction {
  * An enumeration of valid SystemInstructionType's
  */
 export type SystemInstructionType =
+  // FIXME
+  // It would be preferable for this type to be `keyof SystemInstructionInputData`
+  // but Typedoc does not transpile `keyof` expressions.
+  // See https://github.com/TypeStrong/typedoc/issues/1894
   | 'AdvanceNonceAccount'
   | 'Allocate'
   | 'AllocateWithSeed'
@@ -528,18 +566,72 @@ export type SystemInstructionType =
   | 'InitializeNonceAccount'
   | 'Transfer'
   | 'TransferWithSeed'
-  | 'WithdrawNonceAccount';
+  | 'WithdrawNonceAccount'
+  | 'UpgradeNonceAccount';
+
+type SystemInstructionInputData = {
+  AdvanceNonceAccount: IInstructionInputData;
+  Allocate: IInstructionInputData & {
+    space: number;
+  };
+  AllocateWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    programId: Uint8Array;
+    seed: string;
+    space: number;
+  };
+  Assign: IInstructionInputData & {
+    programId: Uint8Array;
+  };
+  AssignWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    seed: string;
+    programId: Uint8Array;
+  };
+  AuthorizeNonceAccount: IInstructionInputData & {
+    authorized: Uint8Array;
+  };
+  Create: IInstructionInputData & {
+    lamports: number;
+    programId: Uint8Array;
+    space: number;
+  };
+  CreateWithSeed: IInstructionInputData & {
+    base: Uint8Array;
+    lamports: number;
+    programId: Uint8Array;
+    seed: string;
+    space: number;
+  };
+  InitializeNonceAccount: IInstructionInputData & {
+    authorized: Uint8Array;
+  };
+  Transfer: IInstructionInputData & {
+    lamports: bigint;
+  };
+  TransferWithSeed: IInstructionInputData & {
+    lamports: bigint;
+    programId: Uint8Array;
+    seed: string;
+  };
+  WithdrawNonceAccount: IInstructionInputData & {
+    lamports: number;
+  };
+  UpgradeNonceAccount: IInstructionInputData;
+};
 
 /**
  * An enumeration of valid system InstructionType's
  * @internal
  */
-export const SYSTEM_INSTRUCTION_LAYOUTS: {
-  [type in SystemInstructionType]: InstructionType;
-} = Object.freeze({
+export const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in SystemInstructionType]: InstructionType<
+    SystemInstructionInputData[Instruction]
+  >;
+}>({
   Create: {
     index: 0,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Create']>([
       BufferLayout.u32('instruction'),
       BufferLayout.ns64('lamports'),
       BufferLayout.ns64('space'),
@@ -548,21 +640,21 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   Assign: {
     index: 1,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Assign']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('programId'),
     ]),
   },
   Transfer: {
     index: 2,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Transfer']>([
       BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
+      u64('lamports'),
     ]),
   },
   CreateWithSeed: {
     index: 3,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['CreateWithSeed']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('base'),
       Layout.rustString('seed'),
@@ -573,49 +665,50 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   AdvanceNonceAccount: {
     index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['AdvanceNonceAccount']
+    >([BufferLayout.u32('instruction')]),
   },
   WithdrawNonceAccount: {
     index: 5,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['WithdrawNonceAccount']
+    >([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')]),
   },
   InitializeNonceAccount: {
     index: 6,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('authorized'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['InitializeNonceAccount']
+    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
   },
   AuthorizeNonceAccount: {
     index: 7,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('authorized'),
-    ]),
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['AuthorizeNonceAccount']
+    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
   },
   Allocate: {
     index: 8,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['Allocate']>([
       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'),
-    ]),
+    layout: BufferLayout.struct<SystemInstructionInputData['AllocateWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        Layout.publicKey('base'),
+        Layout.rustString('seed'),
+        BufferLayout.ns64('space'),
+        Layout.publicKey('programId'),
+      ],
+    ),
   },
   AssignWithSeed: {
     index: 10,
-    layout: BufferLayout.struct([
+    layout: BufferLayout.struct<SystemInstructionInputData['AssignWithSeed']>([
       BufferLayout.u32('instruction'),
       Layout.publicKey('base'),
       Layout.rustString('seed'),
@@ -624,12 +717,20 @@ export const SYSTEM_INSTRUCTION_LAYOUTS: {
   },
   TransferWithSeed: {
     index: 11,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-      Layout.rustString('seed'),
-      Layout.publicKey('programId'),
-    ]),
+    layout: BufferLayout.struct<SystemInstructionInputData['TransferWithSeed']>(
+      [
+        BufferLayout.u32('instruction'),
+        u64('lamports'),
+        Layout.rustString('seed'),
+        Layout.publicKey('programId'),
+      ],
+    ),
+  },
+  UpgradeNonceAccount: {
+    index: 12,
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['UpgradeNonceAccount']
+    >([BufferLayout.u32('instruction')]),
   },
 });
 
@@ -681,7 +782,7 @@ export class SystemProgram {
     if ('basePubkey' in params) {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;
       data = encodeData(type, {
-        lamports: params.lamports,
+        lamports: BigInt(params.lamports),
         seed: params.seed,
         programId: toBuffer(params.programId.toBuffer()),
       });
@@ -692,7 +793,7 @@ export class SystemProgram {
       ];
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
-      data = encodeData(type, {lamports: params.lamports});
+      data = encodeData(type, {lamports: BigInt(params.lamports)});
       keys = [
         {pubkey: params.fromPubkey, isSigner: true, isWritable: true},
         {pubkey: params.toPubkey, isSigner: false, isWritable: true},

diff --git a/src/sysvar.ts b/src/sysvar.ts
@@ -4,6 +4,14 @@ export const SYSVAR_CLOCK_PUBKEY = new PublicKey(
   'SysvarC1ock11111111111111111111111111111111',
 );
 
+export const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey(
+  'SysvarEpochSchedu1e111111111111111111111111',
+);
+
+export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
+  'Sysvar1nstructions1111111111111111111111111',
+);
+
 export const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey(
   'SysvarRecentB1ockHashes11111111111111111111',
 );
@@ -16,10 +24,14 @@ export const SYSVAR_REWARDS_PUBKEY = new PublicKey(
   'SysvarRewards111111111111111111111111111111',
 );
 
-export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey(
-  'SysvarStakeHistory1111111111111111111111111',
+export const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey(
+  'SysvarS1otHashes111111111111111111111111111',
 );
 
-export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
-  'Sysvar1nstructions1111111111111111111111111',
+export const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey(
+  'SysvarS1otHistory11111111111111111111111111',
+);
+
+export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey(
+  'SysvarStakeHistory1111111111111111111111111',
 );
diff --git a/src/transaction-constants.ts b/src/transaction-constants.ts
@@ -0,0 +1,10 @@
+/**
+ * Maximum over-the-wire size of a Transaction
+ *
+ * 1280 is IPv6 minimum MTU
+ * 40 bytes is the size of the IPv6 header
+ * 8 bytes is the size of the fragment header
+ */
+export const PACKET_DATA_SIZE = 1280 - 40 - 8;
+
+export const SIGNATURE_LENGTH_IN_BYTES = 64;
diff --git a/src/transaction.ts b/src/transaction.ts
diff --git a/src/util/__forks__/react-native/url-impl.ts b/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';
diff --git a/src/util/bigint.ts b/src/util/bigint.ts
@@ -0,0 +1,43 @@
+import {Buffer} from 'buffer';
+import {blob, Layout} from '@solana/buffer-layout';
+import {toBigIntLE, toBufferLE} from 'bigint-buffer';
+
+interface EncodeDecode<T> {
+  decode(buffer: Buffer, offset?: number): T;
+  encode(src: T, buffer: Buffer, offset?: number): number;
+}
+
+const encodeDecode = <T>(layout: Layout<T>): EncodeDecode<T> => {
+  const decode = layout.decode.bind(layout);
+  const encode = layout.encode.bind(layout);
+  return {decode, encode};
+};
+
+const bigInt =
+  (length: number) =>
+  (property?: string): Layout<bigint> => {
+    const layout = blob(length, property);
+    const {encode, decode} = encodeDecode(layout);
+
+    const bigIntLayout = layout as Layout<unknown> as Layout<bigint>;
+
+    bigIntLayout.decode = (buffer: Buffer, offset: number) => {
+      const src = decode(buffer, offset);
+      return toBigIntLE(Buffer.from(src));
+    };
+
+    bigIntLayout.encode = (bigInt: bigint, buffer: Buffer, offset: number) => {
+      const src = toBufferLE(bigInt, length);
+      return encode(src, buffer, offset);
+    };
+
+    return bigIntLayout;
+  };
+
+export const u64 = bigInt(8);
+
+export const u128 = bigInt(16);
+
+export const u192 = bigInt(24);
+
+export const u256 = bigInt(32);
diff --git a/src/util/cluster.ts b/src/util/cluster.ts
@@ -2,12 +2,12 @@ const endpoint = {
   http: {
     devnet: 'http://api.devnet.solana.com',
     testnet: 'http://api.testnet.solana.com',
-    'mainnet-beta': 'http://api.mainnet-beta.solana.com',
+    'mainnet-beta': 'http://api.mainnet-beta.solana.com/',
   },
   https: {
     devnet: 'https://api.devnet.solana.com',
     testnet: 'https://api.testnet.solana.com',
-    'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+    'mainnet-beta': 'https://api.mainnet-beta.solana.com/',
   },
 };
 

diff --git a/src/util/url.ts → src/util/makeWebsocketUrl.ts b/src/util/url.ts → src/util/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:';

diff --git a/src/util/send-and-confirm-raw-transaction.ts b/src/util/send-and-confirm-raw-transaction.ts
@@ -1,6 +1,9 @@
 import type {Buffer} from 'buffer';
 
-import {Connection} from '../connection';
+import {
+  BlockheightBasedTransactionConfirmationStrategy,
+  Connection,
+} from '../connection';
 import type {TransactionSignature} from '../transaction';
 import type {ConfirmOptions} from '../connection';
 
@@ -11,30 +14,73 @@ import type {ConfirmOptions} from '../connection';
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
+ * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
  * @param {ConfirmOptions} [options]
  * @returns {Promise<TransactionSignature>}
  */
 export async function sendAndConfirmRawTransaction(
   connection: Connection,
   rawTransaction: Buffer,
+  confirmationStrategy: BlockheightBasedTransactionConfirmationStrategy,
   options?: ConfirmOptions,
+): Promise<TransactionSignature>;
+
+/**
+ * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
+ * is no longer supported and will be removed in a future version.
+ */
+// eslint-disable-next-line no-redeclare
+export async function sendAndConfirmRawTransaction(
+  connection: Connection,
+  rawTransaction: Buffer,
+  options?: ConfirmOptions,
+): Promise<TransactionSignature>;
+
+// eslint-disable-next-line no-redeclare
+export async function sendAndConfirmRawTransaction(
+  connection: Connection,
+  rawTransaction: Buffer,
+  confirmationStrategyOrConfirmOptions:
+    | BlockheightBasedTransactionConfirmationStrategy
+    | ConfirmOptions
+    | undefined,
+  maybeConfirmOptions?: ConfirmOptions,
 ): Promise<TransactionSignature> {
+  let confirmationStrategy:
+    | BlockheightBasedTransactionConfirmationStrategy
+    | undefined;
+  let options: ConfirmOptions | undefined;
+  if (
+    confirmationStrategyOrConfirmOptions &&
+    Object.prototype.hasOwnProperty.call(
+      confirmationStrategyOrConfirmOptions,
+      'lastValidBlockHeight',
+    )
+  ) {
+    confirmationStrategy =
+      confirmationStrategyOrConfirmOptions as BlockheightBasedTransactionConfirmationStrategy;
+    options = maybeConfirmOptions;
+  } else {
+    options = confirmationStrategyOrConfirmOptions as
+      | ConfirmOptions
+      | undefined;
+  }
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
     preflightCommitment: options.preflightCommitment || options.commitment,
+    minContextSlot: options.minContextSlot,
   };
 
   const signature = await connection.sendRawTransaction(
     rawTransaction,
     sendOptions,
   );
 
-  const status = (
-    await connection.confirmTransaction(
-      signature,
-      options && options.commitment,
-    )
-  ).value;
+  const commitment = options && options.commitment;
+  const confirmationPromise = confirmationStrategy
+    ? connection.confirmTransaction(confirmationStrategy, commitment)
+    : connection.confirmTransaction(signature, commitment);
+  const status = (await confirmationPromise).value;
 
   if (status.err) {
     throw new Error(

diff --git a/src/util/send-and-confirm-transaction.ts b/src/util/send-and-confirm-transaction.ts
@@ -24,6 +24,8 @@ export async function sendAndConfirmTransaction(
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
     preflightCommitment: options.preflightCommitment || options.commitment,
+    maxRetries: options.maxRetries,
+    minContextSlot: options.minContextSlot,
   };
 
   const signature = await connection.sendTransaction(
@@ -32,12 +34,25 @@ export async function sendAndConfirmTransaction(
     sendOptions,
   );
 
-  const status = (
-    await connection.confirmTransaction(
-      signature,
-      options && options.commitment,
-    )
-  ).value;
+  const status =
+    transaction.recentBlockhash != null &&
+    transaction.lastValidBlockHeight != null
+      ? (
+          await connection.confirmTransaction(
+            {
+              signature: signature,
+              blockhash: transaction.recentBlockhash,
+              lastValidBlockHeight: transaction.lastValidBlockHeight,
+            },
+            options && options.commitment,
+          )
+        ).value
+      : (
+          await connection.confirmTransaction(
+            signature,
+            options && options.commitment,
+          )
+        ).value;
 
   if (status.err) {
     throw new Error(

diff --git a/src/util/tx-expiry-custom-errors.ts b/src/util/tx-expiry-custom-errors.ts
@@ -0,0 +1,35 @@
+export class TransactionExpiredBlockheightExceededError extends Error {
+  signature: string;
+
+  constructor(signature: string) {
+    super(`Signature ${signature} has expired: block height exceeded.`);
+    this.signature = signature;
+  }
+}
+
+Object.defineProperty(
+  TransactionExpiredBlockheightExceededError.prototype,
+  'name',
+  {
+    value: 'TransactionExpiredBlockheightExceededError',
+  },
+);
+
+export class TransactionExpiredTimeoutError extends Error {
+  signature: string;
+
+  constructor(signature: string, timeoutSeconds: number) {
+    super(
+      `Transaction was not confirmed in ${timeoutSeconds.toFixed(
+        2,
+      )} seconds. It is ` +
+        'unknown if it succeeded or failed. Check signature ' +
+        `${signature} using the Solana Explorer or CLI tools.`,
+    );
+    this.signature = signature;
+  }
+}
+
+Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
+  value: 'TransactionExpiredTimeoutError',
+});
diff --git a/src/util/url-impl.ts b/src/util/url-impl.ts
@@ -0,0 +1,2 @@
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;
diff --git a/src/vote-account.ts b/src/vote-account.ts
@@ -17,24 +17,69 @@ export type Lockout = {
 /**
  * History of how many credits earned by the end of each epoch
  */
-export type EpochCredits = {
+export type EpochCredits = Readonly<{
   epoch: number;
   credits: number;
   prevCredits: number;
-};
+}>;
+
+export type AuthorizedVoter = Readonly<{
+  epoch: number;
+  authorizedVoter: PublicKey;
+}>;
+
+type AuthorizedVoterRaw = Readonly<{
+  authorizedVoter: Uint8Array;
+  epoch: number;
+}>;
+
+type PriorVoters = Readonly<{
+  buf: PriorVoterRaw[];
+  idx: number;
+  isEmpty: number;
+}>;
+
+export type PriorVoter = Readonly<{
+  authorizedPubkey: PublicKey;
+  epochOfLastAuthorizedSwitch: number;
+  targetEpoch: number;
+}>;
+
+type PriorVoterRaw = Readonly<{
+  authorizedPubkey: Uint8Array;
+  epochOfLastAuthorizedSwitch: number;
+  targetEpoch: number;
+}>;
+
+export type BlockTimestamp = Readonly<{
+  slot: number;
+  timestamp: number;
+}>;
+
+type VoteAccountData = Readonly<{
+  authorizedVoters: AuthorizedVoterRaw[];
+  authorizedWithdrawer: Uint8Array;
+  commission: number;
+  epochCredits: EpochCredits[];
+  lastTimestamp: BlockTimestamp;
+  nodePubkey: Uint8Array;
+  priorVoters: PriorVoters;
+  rootSlot: number;
+  rootSlotValid: number;
+  votes: Lockout[];
+}>;
 
 /**
  * See https://github.com/solana-labs/solana/blob/8a12ed029cfa38d4a45400916c2463fb82bbec8c/programs/vote_api/src/vote_state.rs#L68-L88
  *
  * @internal
  */
-const VoteAccountLayout = BufferLayout.struct([
+const VoteAccountLayout = BufferLayout.struct<VoteAccountData>([
   Layout.publicKey('nodePubkey'),
-  Layout.publicKey('authorizedVoterPubkey'),
-  Layout.publicKey('authorizedWithdrawerPubkey'),
+  Layout.publicKey('authorizedWithdrawer'),
   BufferLayout.u8('commission'),
   BufferLayout.nu64(), // votes.length
-  BufferLayout.seq(
+  BufferLayout.seq<Lockout>(
     BufferLayout.struct([
       BufferLayout.nu64('slot'),
       BufferLayout.u32('confirmationCount'),
@@ -44,11 +89,33 @@ const VoteAccountLayout = BufferLayout.struct([
   ),
   BufferLayout.u8('rootSlotValid'),
   BufferLayout.nu64('rootSlot'),
-  BufferLayout.nu64('epoch'),
-  BufferLayout.nu64('credits'),
-  BufferLayout.nu64('lastEpochCredits'),
+  BufferLayout.nu64(), // authorizedVoters.length
+  BufferLayout.seq<AuthorizedVoterRaw>(
+    BufferLayout.struct([
+      BufferLayout.nu64('epoch'),
+      Layout.publicKey('authorizedVoter'),
+    ]),
+    BufferLayout.offset(BufferLayout.u32(), -8),
+    'authorizedVoters',
+  ),
+  BufferLayout.struct<PriorVoters>(
+    [
+      BufferLayout.seq(
+        BufferLayout.struct([
+          Layout.publicKey('authorizedPubkey'),
+          BufferLayout.nu64('epochOfLastAuthorizedSwitch'),
+          BufferLayout.nu64('targetEpoch'),
+        ]),
+        32,
+        'buf',
+      ),
+      BufferLayout.nu64('idx'),
+      BufferLayout.u8('isEmpty'),
+    ],
+    'priorVoters',
+  ),
   BufferLayout.nu64(), // epochCredits.length
-  BufferLayout.seq(
+  BufferLayout.seq<EpochCredits>(
     BufferLayout.struct([
       BufferLayout.nu64('epoch'),
       BufferLayout.nu64('credits'),
@@ -57,50 +124,51 @@ const VoteAccountLayout = BufferLayout.struct([
     BufferLayout.offset(BufferLayout.u32(), -8),
     'epochCredits',
   ),
+  BufferLayout.struct<BlockTimestamp>(
+    [BufferLayout.nu64('slot'), BufferLayout.nu64('timestamp')],
+    'lastTimestamp',
+  ),
 ]);
 
 type VoteAccountArgs = {
   nodePubkey: PublicKey;
-  authorizedVoterPubkey: PublicKey;
-  authorizedWithdrawerPubkey: PublicKey;
+  authorizedWithdrawer: PublicKey;
   commission: number;
-  votes: Array<Lockout>;
   rootSlot: number | null;
-  epoch: number;
-  credits: number;
-  lastEpochCredits: number;
-  epochCredits: Array<EpochCredits>;
+  votes: Lockout[];
+  authorizedVoters: AuthorizedVoter[];
+  priorVoters: PriorVoter[];
+  epochCredits: EpochCredits[];
+  lastTimestamp: BlockTimestamp;
 };
 
 /**
  * VoteAccount class
  */
 export class VoteAccount {
   nodePubkey: PublicKey;
-  authorizedVoterPubkey: PublicKey;
-  authorizedWithdrawerPubkey: PublicKey;
+  authorizedWithdrawer: PublicKey;
   commission: number;
-  votes: Array<Lockout>;
   rootSlot: number | null;
-  epoch: number;
-  credits: number;
-  lastEpochCredits: number;
-  epochCredits: Array<EpochCredits>;
+  votes: Lockout[];
+  authorizedVoters: AuthorizedVoter[];
+  priorVoters: PriorVoter[];
+  epochCredits: EpochCredits[];
+  lastTimestamp: BlockTimestamp;
 
   /**
    * @internal
    */
   constructor(args: VoteAccountArgs) {
     this.nodePubkey = args.nodePubkey;
-    this.authorizedVoterPubkey = args.authorizedVoterPubkey;
-    this.authorizedWithdrawerPubkey = args.authorizedWithdrawerPubkey;
+    this.authorizedWithdrawer = args.authorizedWithdrawer;
     this.commission = args.commission;
-    this.votes = args.votes;
     this.rootSlot = args.rootSlot;
-    this.epoch = args.epoch;
-    this.credits = args.credits;
-    this.lastEpochCredits = args.lastEpochCredits;
+    this.votes = args.votes;
+    this.authorizedVoters = args.authorizedVoters;
+    this.priorVoters = args.priorVoters;
     this.epochCredits = args.epochCredits;
+    this.lastTimestamp = args.lastTimestamp;
   }
 
   /**
@@ -112,7 +180,8 @@ export class VoteAccount {
   static fromAccountData(
     buffer: Buffer | Uint8Array | Array<number>,
   ): VoteAccount {
-    const va = VoteAccountLayout.decode(toBuffer(buffer), 0);
+    const versionOffset = 4;
+    const va = VoteAccountLayout.decode(toBuffer(buffer), versionOffset);
 
     let rootSlot: number | null = va.rootSlot;
     if (!va.rootSlotValid) {
@@ -121,15 +190,47 @@ export class VoteAccount {
 
     return new VoteAccount({
       nodePubkey: new PublicKey(va.nodePubkey),
-      authorizedVoterPubkey: new PublicKey(va.authorizedVoterPubkey),
-      authorizedWithdrawerPubkey: new PublicKey(va.authorizedWithdrawerPubkey),
+      authorizedWithdrawer: new PublicKey(va.authorizedWithdrawer),
       commission: va.commission,
       votes: va.votes,
       rootSlot,
-      epoch: va.epoch,
-      credits: va.credits,
-      lastEpochCredits: va.lastEpochCredits,
+      authorizedVoters: va.authorizedVoters.map(parseAuthorizedVoter),
+      priorVoters: getPriorVoters(va.priorVoters),
       epochCredits: va.epochCredits,
+      lastTimestamp: va.lastTimestamp,
     });
   }
 }
+
+function parseAuthorizedVoter({
+  authorizedVoter,
+  epoch,
+}: AuthorizedVoterRaw): AuthorizedVoter {
+  return {
+    epoch,
+    authorizedVoter: new PublicKey(authorizedVoter),
+  };
+}
+
+function parsePriorVoters({
+  authorizedPubkey,
+  epochOfLastAuthorizedSwitch,
+  targetEpoch,
+}: PriorVoterRaw): PriorVoter {
+  return {
+    authorizedPubkey: new PublicKey(authorizedPubkey),
+    epochOfLastAuthorizedSwitch,
+    targetEpoch,
+  };
+}
+
+function getPriorVoters({buf, idx, isEmpty}: PriorVoters): PriorVoter[] {
+  if (isEmpty) {
+    return [];
+  }
+
+  return [
+    ...buf.slice(idx + 1).map(parsePriorVoters),
+    ...buf.slice(0, idx).map(parsePriorVoters),
+  ];
+}
diff --git a/src/vote-program.ts b/src/vote-program.ts
diff --git a/test/address-lookup-table-program.test.ts b/test/address-lookup-table-program.test.ts
@@ -0,0 +1,266 @@
+import {expect, use} from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import {
+  Keypair,
+  AddressLookupTableProgram,
+  Transaction,
+  AddressLookupTableInstruction,
+  Connection,
+  sendAndConfirmTransaction,
+} from '../src';
+import {sleep} from '../src/util/sleep';
+import {helpers} from './mocks/rpc-http';
+import {url} from './url';
+
+use(chaiAsPromised);
+
+describe('AddressLookupTableProgram', () => {
+  it('createAddressLookupTable', () => {
+    const recentSlot = 0;
+    const authorityPubkey = Keypair.generate().publicKey;
+    const payerPubkey = Keypair.generate().publicKey;
+    const [instruction] = AddressLookupTableProgram.createLookupTable({
+      authority: authorityPubkey,
+      payer: payerPubkey,
+      recentSlot,
+    });
+
+    const transaction = new Transaction().add(instruction);
+    const createLutParams = {
+      authority: authorityPubkey,
+      payer: payerPubkey,
+      recentSlot,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(createLutParams).to.eql(
+      AddressLookupTableInstruction.decodeCreateLookupTable(instruction),
+    );
+  });
+
+  it('extendLookupTableWithPayer', () => {
+    const lutAddress = Keypair.generate().publicKey;
+    const authorityPubkey = Keypair.generate().publicKey;
+    const payerPubkey = Keypair.generate().publicKey;
+
+    const addressesToAdd = [
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+    ];
+
+    const instruction = AddressLookupTableProgram.extendLookupTable({
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      payer: payerPubkey,
+      addresses: addressesToAdd,
+    });
+    const transaction = new Transaction().add(instruction);
+    const extendLutParams = {
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      payer: payerPubkey,
+      addresses: addressesToAdd,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(extendLutParams).to.eql(
+      AddressLookupTableInstruction.decodeExtendLookupTable(instruction),
+    );
+  });
+
+  it('extendLookupTableWithoutPayer', () => {
+    const lutAddress = Keypair.generate().publicKey;
+    const authorityPubkey = Keypair.generate().publicKey;
+
+    const addressesToAdd = [
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+      Keypair.generate().publicKey,
+    ];
+
+    const instruction = AddressLookupTableProgram.extendLookupTable({
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      addresses: addressesToAdd,
+    });
+    const transaction = new Transaction().add(instruction);
+    const extendLutParams = {
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      payer: undefined,
+      addresses: addressesToAdd,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(extendLutParams).to.eql(
+      AddressLookupTableInstruction.decodeExtendLookupTable(instruction),
+    );
+  });
+
+  it('closeLookupTable', () => {
+    const lutAddress = Keypair.generate().publicKey;
+    const authorityPubkey = Keypair.generate().publicKey;
+    const recipientPubkey = Keypair.generate().publicKey;
+
+    const instruction = AddressLookupTableProgram.closeLookupTable({
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      recipient: recipientPubkey,
+    });
+    const transaction = new Transaction().add(instruction);
+    const closeLutParams = {
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+      recipient: recipientPubkey,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(closeLutParams).to.eql(
+      AddressLookupTableInstruction.decodeCloseLookupTable(instruction),
+    );
+  });
+
+  it('freezeLookupTable', () => {
+    const lutAddress = Keypair.generate().publicKey;
+    const authorityPubkey = Keypair.generate().publicKey;
+
+    const instruction = AddressLookupTableProgram.freezeLookupTable({
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+    });
+    const transaction = new Transaction().add(instruction);
+    const freezeLutParams = {
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(freezeLutParams).to.eql(
+      AddressLookupTableInstruction.decodeFreezeLookupTable(instruction),
+    );
+  });
+
+  it('deactivateLookupTable', () => {
+    const lutAddress = Keypair.generate().publicKey;
+    const authorityPubkey = Keypair.generate().publicKey;
+
+    const instruction = AddressLookupTableProgram.deactivateLookupTable({
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+    });
+
+    const transaction = new Transaction().add(instruction);
+    const deactivateLutParams = {
+      lookupTable: lutAddress,
+      authority: authorityPubkey,
+    };
+    expect(transaction.instructions).to.have.length(1);
+    expect(deactivateLutParams).to.eql(
+      AddressLookupTableInstruction.decodeDeactivateLookupTable(instruction),
+    );
+  });
+
+  if (process.env.TEST_LIVE) {
+    it('live address lookup table actions', async () => {
+      const connection = new Connection(url, 'confirmed');
+      const authority = Keypair.generate();
+      const payer = Keypair.generate();
+
+      const slot = await connection.getSlot('confirmed');
+      const payerMinBalance =
+        await connection.getMinimumBalanceForRentExemption(44 * 10);
+
+      const [createInstruction, lutAddress] =
+        AddressLookupTableProgram.createLookupTable({
+          authority: authority.publicKey,
+          payer: payer.publicKey,
+          recentSlot: slot,
+        });
+
+      await helpers.airdrop({
+        connection,
+        address: payer.publicKey,
+        amount: payerMinBalance,
+      });
+
+      await helpers.airdrop({
+        connection,
+        address: authority.publicKey,
+        amount: payerMinBalance,
+      });
+
+      // Creating a new lut
+      const createLutTransaction = new Transaction();
+      createLutTransaction.add(createInstruction);
+      createLutTransaction.feePayer = payer.publicKey;
+
+      await sendAndConfirmTransaction(
+        connection,
+        createLutTransaction,
+        [authority, payer],
+        {preflightCommitment: 'confirmed'},
+      );
+
+      await sleep(500);
+
+      // Extending a lut without a payer
+      await helpers.airdrop({
+        connection,
+        address: lutAddress,
+        amount: payerMinBalance,
+      });
+
+      const extendWithoutPayerInstruction =
+        AddressLookupTableProgram.extendLookupTable({
+          lookupTable: lutAddress,
+          authority: authority.publicKey,
+          addresses: [...Array(10)].map(() => Keypair.generate().publicKey),
+        });
+      const extendLutWithoutPayerTransaction = new Transaction();
+      extendLutWithoutPayerTransaction.add(extendWithoutPayerInstruction);
+
+      await sendAndConfirmTransaction(
+        connection,
+        extendLutWithoutPayerTransaction,
+        [authority],
+        {preflightCommitment: 'confirmed'},
+      );
+
+      // Extending an lut with a payer
+      const extendWithPayerInstruction =
+        AddressLookupTableProgram.extendLookupTable({
+          lookupTable: lutAddress,
+          authority: authority.publicKey,
+          payer: payer.publicKey,
+          addresses: [...Array(10)].map(() => Keypair.generate().publicKey),
+        });
+
+      const extendLutWithPayerTransaction = new Transaction();
+      extendLutWithPayerTransaction.add(extendWithPayerInstruction);
+
+      await sendAndConfirmTransaction(
+        connection,
+        extendLutWithPayerTransaction,
+        [authority, payer],
+        {preflightCommitment: 'confirmed'},
+      );
+
+      //deactivating the lut
+      const deactivateInstruction =
+        AddressLookupTableProgram.deactivateLookupTable({
+          lookupTable: lutAddress,
+          authority: authority.publicKey,
+        });
+
+      const deactivateLutTransaction = new Transaction();
+      deactivateLutTransaction.add(deactivateInstruction);
+      await sendAndConfirmTransaction(
+        connection,
+        deactivateLutTransaction,
+        [authority],
+        {preflightCommitment: 'confirmed'},
+      );
+
+      // After deactivation, LUTs can be closed *only* after a short perioid of time
+    }).timeout(10 * 1000);
+  }
+});
diff --git a/test/bpf-loader.test.ts b/test/bpf-loader.test.ts
@@ -147,6 +147,25 @@ if (process.env.TEST_LIVE) {
         );
       });
 
+      it('simulate transaction with returnData', async () => {
+        const simulatedTransaction = new Transaction().add({
+          keys: [
+            {pubkey: payerAccount.publicKey, isSigner: true, isWritable: true},
+          ],
+          programId: program.publicKey,
+        });
+        const {err, returnData} = (
+          await connection.simulateTransaction(simulatedTransaction, [
+            payerAccount,
+          ])
+        ).value;
+        const expectedReturnData = new Uint8Array([1, 2, 3]);
+        var decodedData = Buffer.from(returnData.data[0], returnData.data[1]);
+        expect(err).to.be.null;
+        expect(returnData.programId).to.eql(program.publicKey.toString());
+        expect(decodedData).to.eql(expectedReturnData);
+      });
+
       it('deprecated - simulate transaction without signature verification', async () => {
         const simulatedTransaction = new Transaction().add({
           keys: [
@@ -176,9 +195,9 @@ if (process.env.TEST_LIVE) {
       });
 
       it('simulate transaction without signature verification', async () => {
-        const simulatedTransaction = new Transaction({
-          feePayer: payerAccount.publicKey,
-        }).add({
+        const simulatedTransaction = new Transaction();
+        simulatedTransaction.feePayer = payerAccount.publicKey;
+        simulatedTransaction.add({
           keys: [
             {pubkey: payerAccount.publicKey, isSigner: true, isWritable: true},
           ],

diff --git a/test/compute-budget.test.ts b/test/compute-budget.test.ts
@@ -0,0 +1,220 @@
+import {expect, use} from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import {
+  Keypair,
+  Connection,
+  LAMPORTS_PER_SOL,
+  Transaction,
+  ComputeBudgetProgram,
+  ComputeBudgetInstruction,
+  sendAndConfirmTransaction,
+} from '../src';
+import {helpers} from './mocks/rpc-http';
+import {url} from './url';
+
+use(chaiAsPromised);
+
+describe('ComputeBudgetProgram', () => {
+  it('requestUnits', () => {
+    const params = {
+      units: 150000,
+      additionalFee: LAMPORTS_PER_SOL,
+    };
+    const ix = ComputeBudgetProgram.requestUnits(params);
+    const decodedParams = ComputeBudgetInstruction.decodeRequestUnits(ix);
+    expect(params).to.eql(decodedParams);
+    expect(ComputeBudgetInstruction.decodeInstructionType(ix)).to.eq(
+      'RequestUnits',
+    );
+  });
+
+  it('requestHeapFrame', () => {
+    const params = {
+      bytes: 33 * 1024,
+    };
+    const ix = ComputeBudgetProgram.requestHeapFrame(params);
+    const decodedParams = ComputeBudgetInstruction.decodeRequestHeapFrame(ix);
+    expect(decodedParams).to.eql(params);
+    expect(ComputeBudgetInstruction.decodeInstructionType(ix)).to.eq(
+      'RequestHeapFrame',
+    );
+  });
+
+  it('setComputeUnitLimit', () => {
+    const params = {
+      units: 50_000,
+    };
+    const ix = ComputeBudgetProgram.setComputeUnitLimit(params);
+    const decodedParams =
+      ComputeBudgetInstruction.decodeSetComputeUnitLimit(ix);
+    expect(decodedParams).to.eql(params);
+    expect(ComputeBudgetInstruction.decodeInstructionType(ix)).to.eq(
+      'SetComputeUnitLimit',
+    );
+  });
+
+  it('setComputeUnitPrice', () => {
+    const params = {
+      microLamports: 100_000,
+    };
+    const ix = ComputeBudgetProgram.setComputeUnitPrice(params);
+    const expectedParams = {
+      ...params,
+      microLamports: BigInt(params.microLamports),
+    };
+    const decodedParams =
+      ComputeBudgetInstruction.decodeSetComputeUnitPrice(ix);
+    expect(decodedParams).to.eql(expectedParams);
+    expect(ComputeBudgetInstruction.decodeInstructionType(ix)).to.eq(
+      'SetComputeUnitPrice',
+    );
+  });
+
+  if (process.env.TEST_LIVE) {
+    it('send live request units ix', async () => {
+      const connection = new Connection(url, 'confirmed');
+      const FEE_AMOUNT = LAMPORTS_PER_SOL;
+      const STARTING_AMOUNT = 2 * LAMPORTS_PER_SOL;
+      const baseAccount = Keypair.generate();
+      const basePubkey = baseAccount.publicKey;
+      await helpers.airdrop({
+        connection,
+        address: basePubkey,
+        amount: STARTING_AMOUNT,
+      });
+
+      const additionalFeeTooHighTransaction = new Transaction().add(
+        ComputeBudgetProgram.requestUnits({
+          units: 150_000,
+          additionalFee: STARTING_AMOUNT,
+        }),
+      );
+
+      await expect(
+        sendAndConfirmTransaction(
+          connection,
+          additionalFeeTooHighTransaction,
+          [baseAccount],
+          {preflightCommitment: 'confirmed'},
+        ),
+      ).to.be.rejected;
+
+      const validAdditionalFeeTransaction = new Transaction().add(
+        ComputeBudgetProgram.requestUnits({
+          units: 150_000,
+          additionalFee: FEE_AMOUNT,
+        }),
+      );
+      await sendAndConfirmTransaction(
+        connection,
+        validAdditionalFeeTransaction,
+        [baseAccount],
+        {preflightCommitment: 'confirmed'},
+      );
+      expect(await connection.getBalance(baseAccount.publicKey)).to.be.at.most(
+        STARTING_AMOUNT - FEE_AMOUNT,
+      );
+    });
+
+    it('send live request heap ix', async () => {
+      const connection = new Connection(url, 'confirmed');
+      const STARTING_AMOUNT = 2 * LAMPORTS_PER_SOL;
+      const baseAccount = Keypair.generate();
+      const basePubkey = baseAccount.publicKey;
+      await helpers.airdrop({
+        connection,
+        address: basePubkey,
+        amount: STARTING_AMOUNT,
+      });
+
+      async function expectRequestHeapFailure(bytes: number) {
+        const requestHeapFrameTransaction = new Transaction().add(
+          ComputeBudgetProgram.requestHeapFrame({bytes}),
+        );
+        await expect(
+          sendAndConfirmTransaction(
+            connection,
+            requestHeapFrameTransaction,
+            [baseAccount],
+            {preflightCommitment: 'confirmed'},
+          ),
+        ).to.be.rejected;
+      }
+      const NOT_MULTIPLE_OF_1024 = 33 * 1024 + 1;
+      const BELOW_MIN = 1024;
+      const ABOVE_MAX = 257 * 1024;
+      await expectRequestHeapFailure(NOT_MULTIPLE_OF_1024);
+      await expectRequestHeapFailure(BELOW_MIN);
+      await expectRequestHeapFailure(ABOVE_MAX);
+
+      const VALID_BYTES = 33 * 1024;
+      const requestHeapFrameTransaction = new Transaction().add(
+        ComputeBudgetProgram.requestHeapFrame({bytes: VALID_BYTES}),
+      );
+      await sendAndConfirmTransaction(
+        connection,
+        requestHeapFrameTransaction,
+        [baseAccount],
+        {preflightCommitment: 'confirmed'},
+      );
+    });
+
+    it('send live compute unit ixs', async () => {
+      const connection = new Connection(url, 'confirmed');
+      const FEE_AMOUNT = LAMPORTS_PER_SOL;
+      const STARTING_AMOUNT = 2 * LAMPORTS_PER_SOL;
+      const baseAccount = Keypair.generate();
+      const basePubkey = baseAccount.publicKey;
+      await helpers.airdrop({
+        connection,
+        address: basePubkey,
+        amount: STARTING_AMOUNT,
+      });
+
+      // lamport fee = 2B * 1M / 1M = 2 SOL
+      const prioritizationFeeTooHighTransaction = new Transaction()
+        .add(
+          ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: 2_000_000_000,
+          }),
+        )
+        .add(
+          ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1_000_000,
+          }),
+        );
+
+      await expect(
+        sendAndConfirmTransaction(
+          connection,
+          prioritizationFeeTooHighTransaction,
+          [baseAccount],
+          {preflightCommitment: 'confirmed'},
+        ),
+      ).to.be.rejected;
+
+      // lamport fee = 1B * 1M / 1M = 1 SOL
+      const validPrioritizationFeeTransaction = new Transaction()
+        .add(
+          ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: 1_000_000_000,
+          }),
+        )
+        .add(
+          ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1_000_000,
+          }),
+        );
+      await sendAndConfirmTransaction(
+        connection,
+        validPrioritizationFeeTransaction,
+        [baseAccount],
+        {preflightCommitment: 'confirmed'},
+      );
+      expect(await connection.getBalance(baseAccount.publicKey)).to.be.at.most(
+        STARTING_AMOUNT - FEE_AMOUNT,
+      );
+    });
+  }
+});
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		export {default} from 'react-native-url-polyfill';
		export * from 'react-native-url-polyfill';
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		export const URL = globalThis.URL;
		export const URLSearchParams = globalThis.URLSearchParams;