@solana/web3.js 1.51.0 → 1.54.0

package/src/message/v0.ts

@@ -0,0 +1,324 @@
+import bs58 from 'bs58';
+import * as BufferLayout from '@solana/buffer-layout';
+
+import * as Layout from '../layout';
+import {Blockhash} from '../blockhash';
+import {
+  MessageHeader,
+  MessageAddressTableLookup,
+  MessageCompiledInstruction,
+} from './index';
+import {PublicKey, PUBLIC_KEY_LENGTH} from '../publickey';
+import * as shortvec from '../utils/shortvec-encoding';
+import assert from '../utils/assert';
+import {PACKET_DATA_SIZE, VERSION_PREFIX_MASK} from '../transaction/constants';
+
+/**
+ * Message constructor arguments
+ */
+export type MessageV0Args = {
+  /** The message header, identifying signed and read-only `accountKeys` */
+  header: MessageHeader;
+  /** The static account keys used by this transaction */
+  staticAccountKeys: PublicKey[];
+  /** The hash of a recent ledger block */
+  recentBlockhash: Blockhash;
+  /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+  compiledInstructions: MessageCompiledInstruction[];
+  /** Instructions that will be executed in sequence and committed in one atomic transaction if all succeed. */
+  addressTableLookups: MessageAddressTableLookup[];
+};
+
+export class MessageV0 {
+  header: MessageHeader;
+  staticAccountKeys: Array<PublicKey>;
+  recentBlockhash: Blockhash;
+  compiledInstructions: Array<MessageCompiledInstruction>;
+  addressTableLookups: Array<MessageAddressTableLookup>;
+
+  constructor(args: MessageV0Args) {
+    this.header = args.header;
+    this.staticAccountKeys = args.staticAccountKeys;
+    this.recentBlockhash = args.recentBlockhash;
+    this.compiledInstructions = args.compiledInstructions;
+    this.addressTableLookups = args.addressTableLookups;
+  }
+
+  get version(): 0 {
+    return 0;
+  }
+
+  serialize(): Uint8Array {
+    const encodedStaticAccountKeysLength = Array<number>();
+    shortvec.encodeLength(
+      encodedStaticAccountKeysLength,
+      this.staticAccountKeys.length,
+    );
+
+    const serializedInstructions = this.serializeInstructions();
+    const encodedInstructionsLength = Array<number>();
+    shortvec.encodeLength(
+      encodedInstructionsLength,
+      this.compiledInstructions.length,
+    );
+
+    const serializedAddressTableLookups = this.serializeAddressTableLookups();
+    const encodedAddressTableLookupsLength = Array<number>();
+    shortvec.encodeLength(
+      encodedAddressTableLookupsLength,
+      this.addressTableLookups.length,
+    );
+
+    const messageLayout = BufferLayout.struct<{
+      prefix: number;
+      header: MessageHeader;
+      staticAccountKeysLength: Uint8Array;
+      staticAccountKeys: Array<Uint8Array>;
+      recentBlockhash: Uint8Array;
+      instructionsLength: Uint8Array;
+      serializedInstructions: Uint8Array;
+      addressTableLookupsLength: Uint8Array;
+      serializedAddressTableLookups: Uint8Array;
+    }>([
+      BufferLayout.u8('prefix'),
+      BufferLayout.struct<MessageHeader>(
+        [
+          BufferLayout.u8('numRequiredSignatures'),
+          BufferLayout.u8('numReadonlySignedAccounts'),
+          BufferLayout.u8('numReadonlyUnsignedAccounts'),
+        ],
+        'header',
+      ),
+      BufferLayout.blob(
+        encodedStaticAccountKeysLength.length,
+        'staticAccountKeysLength',
+      ),
+      BufferLayout.seq(
+        Layout.publicKey(),
+        this.staticAccountKeys.length,
+        'staticAccountKeys',
+      ),
+      Layout.publicKey('recentBlockhash'),
+      BufferLayout.blob(encodedInstructionsLength.length, 'instructionsLength'),
+      BufferLayout.blob(
+        serializedInstructions.length,
+        'serializedInstructions',
+      ),
+      BufferLayout.blob(
+        encodedAddressTableLookupsLength.length,
+        'addressTableLookupsLength',
+      ),
+      BufferLayout.blob(
+        serializedAddressTableLookups.length,
+        'serializedAddressTableLookups',
+      ),
+    ]);
+
+    const serializedMessage = new Uint8Array(PACKET_DATA_SIZE);
+    const MESSAGE_VERSION_0_PREFIX = 1 << 7;
+    const serializedMessageLength = messageLayout.encode(
+      {
+        prefix: MESSAGE_VERSION_0_PREFIX,
+        header: this.header,
+        staticAccountKeysLength: new Uint8Array(encodedStaticAccountKeysLength),
+        staticAccountKeys: this.staticAccountKeys.map(key => key.toBytes()),
+        recentBlockhash: bs58.decode(this.recentBlockhash),
+        instructionsLength: new Uint8Array(encodedInstructionsLength),
+        serializedInstructions,
+        addressTableLookupsLength: new Uint8Array(
+          encodedAddressTableLookupsLength,
+        ),
+        serializedAddressTableLookups,
+      },
+      serializedMessage,
+    );
+    return serializedMessage.slice(0, serializedMessageLength);
+  }
+
+  private serializeInstructions(): Uint8Array {
+    let serializedLength = 0;
+    const serializedInstructions = new Uint8Array(PACKET_DATA_SIZE);
+    for (const instruction of this.compiledInstructions) {
+      const encodedAccountKeyIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedAccountKeyIndexesLength,
+        instruction.accountKeyIndexes.length,
+      );
+
+      const encodedDataLength = Array<number>();
+      shortvec.encodeLength(encodedDataLength, instruction.data.length);
+
+      const instructionLayout = BufferLayout.struct<{
+        programIdIndex: number;
+        encodedAccountKeyIndexesLength: Uint8Array;
+        accountKeyIndexes: number[];
+        encodedDataLength: Uint8Array;
+        data: Uint8Array;
+      }>([
+        BufferLayout.u8('programIdIndex'),
+        BufferLayout.blob(
+          encodedAccountKeyIndexesLength.length,
+          'encodedAccountKeyIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          instruction.accountKeyIndexes.length,
+          'accountKeyIndexes',
+        ),
+        BufferLayout.blob(encodedDataLength.length, 'encodedDataLength'),
+        BufferLayout.blob(instruction.data.length, 'data'),
+      ]);
+
+      serializedLength += instructionLayout.encode(
+        {
+          programIdIndex: instruction.programIdIndex,
+          encodedAccountKeyIndexesLength: new Uint8Array(
+            encodedAccountKeyIndexesLength,
+          ),
+          accountKeyIndexes: instruction.accountKeyIndexes,
+          encodedDataLength: new Uint8Array(encodedDataLength),
+          data: instruction.data,
+        },
+        serializedInstructions,
+        serializedLength,
+      );
+    }
+
+    return serializedInstructions.slice(0, serializedLength);
+  }
+
+  private serializeAddressTableLookups(): Uint8Array {
+    let serializedLength = 0;
+    const serializedAddressTableLookups = new Uint8Array(PACKET_DATA_SIZE);
+    for (const lookup of this.addressTableLookups) {
+      const encodedWritableIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedWritableIndexesLength,
+        lookup.writableIndexes.length,
+      );
+
+      const encodedReadonlyIndexesLength = Array<number>();
+      shortvec.encodeLength(
+        encodedReadonlyIndexesLength,
+        lookup.readonlyIndexes.length,
+      );
+
+      const addressTableLookupLayout = BufferLayout.struct<{
+        accountKey: Uint8Array;
+        encodedWritableIndexesLength: Uint8Array;
+        writableIndexes: number[];
+        encodedReadonlyIndexesLength: Uint8Array;
+        readonlyIndexes: number[];
+      }>([
+        Layout.publicKey('accountKey'),
+        BufferLayout.blob(
+          encodedWritableIndexesLength.length,
+          'encodedWritableIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          lookup.writableIndexes.length,
+          'writableIndexes',
+        ),
+        BufferLayout.blob(
+          encodedReadonlyIndexesLength.length,
+          'encodedReadonlyIndexesLength',
+        ),
+        BufferLayout.seq(
+          BufferLayout.u8(),
+          lookup.readonlyIndexes.length,
+          'readonlyIndexes',
+        ),
+      ]);
+
+      serializedLength += addressTableLookupLayout.encode(
+        {
+          accountKey: lookup.accountKey.toBytes(),
+          encodedWritableIndexesLength: new Uint8Array(
+            encodedWritableIndexesLength,
+          ),
+          writableIndexes: lookup.writableIndexes,
+          encodedReadonlyIndexesLength: new Uint8Array(
+            encodedReadonlyIndexesLength,
+          ),
+          readonlyIndexes: lookup.readonlyIndexes,
+        },
+        serializedAddressTableLookups,
+        serializedLength,
+      );
+    }
+
+    return serializedAddressTableLookups.slice(0, serializedLength);
+  }
+
+  static deserialize(serializedMessage: Uint8Array): MessageV0 {
+    let byteArray = [...serializedMessage];
+
+    const prefix = byteArray.shift() as number;
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK;
+    assert(
+      prefix !== maskedPrefix,
+      `Expected versioned message but received legacy message`,
+    );
+
+    const version = maskedPrefix;
+    assert(
+      version === 0,
+      `Expected versioned message with version 0 but found version ${version}`,
+    );
+
+    const header: MessageHeader = {
+      numRequiredSignatures: byteArray.shift() as number,
+      numReadonlySignedAccounts: byteArray.shift() as number,
+      numReadonlyUnsignedAccounts: byteArray.shift() as number,
+    };
+
+    const staticAccountKeys = [];
+    const staticAccountKeysLength = shortvec.decodeLength(byteArray);
+    for (let i = 0; i < staticAccountKeysLength; i++) {
+      staticAccountKeys.push(
+        new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH)),
+      );
+    }
+
+    const recentBlockhash = bs58.encode(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+
+    const instructionCount = shortvec.decodeLength(byteArray);
+    const compiledInstructions: MessageCompiledInstruction[] = [];
+    for (let i = 0; i < instructionCount; i++) {
+      const programIdIndex = byteArray.shift() as number;
+      const accountKeyIndexesLength = shortvec.decodeLength(byteArray);
+      const accountKeyIndexes = byteArray.splice(0, accountKeyIndexesLength);
+      const dataLength = shortvec.decodeLength(byteArray);
+      const data = new Uint8Array(byteArray.splice(0, dataLength));
+      compiledInstructions.push({
+        programIdIndex,
+        accountKeyIndexes,
+        data,
+      });
+    }
+
+    const addressTableLookupsCount = shortvec.decodeLength(byteArray);
+    const addressTableLookups: MessageAddressTableLookup[] = [];
+    for (let i = 0; i < addressTableLookupsCount; i++) {
+      const accountKey = new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH));
+      const writableIndexesLength = shortvec.decodeLength(byteArray);
+      const writableIndexes = byteArray.splice(0, writableIndexesLength);
+      const readonlyIndexesLength = shortvec.decodeLength(byteArray);
+      const readonlyIndexes = byteArray.splice(0, readonlyIndexesLength);
+      addressTableLookups.push({
+        accountKey,
+        writableIndexes,
+        readonlyIndexes,
+      });
+    }
+
+    return new MessageV0({
+      header,
+      staticAccountKeys,
+      recentBlockhash,
+      compiledInstructions,
+      addressTableLookups,
+    });
+  }
+}

package/src/message/versioned.ts

@@ -0,0 +1,27 @@
+import {VERSION_PREFIX_MASK} from '../transaction/constants';
+import {Message} from './legacy';
+import {MessageV0} from './v0';
+
+export type VersionedMessage = Message | MessageV0;
+// eslint-disable-next-line no-redeclare
+export const VersionedMessage = {
+  deserialize: (serializedMessage: Uint8Array): VersionedMessage => {
+    const prefix = serializedMessage[0];
+    const maskedPrefix = prefix & VERSION_PREFIX_MASK;
+
+    // if the highest bit of the prefix is not set, the message is not versioned
+    if (maskedPrefix === prefix) {
+      return Message.from(serializedMessage);
+    }
+
+    // the lower 7 bits of the prefix indicate the message version
+    const version = maskedPrefix;
+    if (version === 0) {
+      return MessageV0.deserialize(serializedMessage);
+    } else {
+      throw new Error(
+        `Transaction message version ${version} deserialization is not supported`,
+      );
+    }
+  },
+};

package/src/nonce-account.ts

@@ -6,7 +6,7 @@ import * as Layout from './layout';
 import {PublicKey} from './publickey';
 import type {FeeCalculator} from './fee-calculator';
 import {FeeCalculatorLayout} from './fee-calculator';
-import {toBuffer} from './util/to-buffer';
+import {toBuffer} from './utils/to-buffer';
 
 /**
  * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32

package/src/{address-lookup-table-program.ts → programs/address-lookup-table/index.ts}

@@ -1,12 +1,14 @@
 import {toBufferLE} from 'bigint-buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
-import * as Layout from './layout';
-import {PublicKey} from './publickey';
-import * as bigintLayout from './util/bigint';
-import {SystemProgram} from './system-program';
-import {TransactionInstruction} from './transaction';
-import {decodeData, encodeData, IInstructionInputData} from './instruction';
+import * as Layout from '../../layout';
+import {PublicKey} from '../../publickey';
+import * as bigintLayout from '../../utils/bigint';
+import {SystemProgram} from '../system';
+import {TransactionInstruction} from '../../transaction';
+import {decodeData, encodeData, IInstructionInputData} from '../../instruction';
+
+export * from './state';
 
 export type CreateLookupTableParams = {
   /** Account used to derive and control the new address lookup table. */

package/src/programs/address-lookup-table/state.ts

@@ -0,0 +1,84 @@
+import * as BufferLayout from '@solana/buffer-layout';
+
+import assert from '../../utils/assert';
+import * as Layout from '../../layout';
+import {PublicKey} from '../../publickey';
+import {u64} from '../../utils/bigint';
+import {decodeData} from '../../account-data';
+
+export type AddressLookupTableState = {
+  deactivationSlot: bigint;
+  lastExtendedSlot: number;
+  lastExtendedSlotStartIndex: number;
+  authority?: PublicKey;
+  addresses: Array<PublicKey>;
+};
+
+export type AddressLookupTableAccountArgs = {
+  key: PublicKey;
+  state: AddressLookupTableState;
+};
+
+/// The serialized size of lookup table metadata
+const LOOKUP_TABLE_META_SIZE = 56;
+
+export class AddressLookupTableAccount {
+  key: PublicKey;
+  state: AddressLookupTableState;
+
+  constructor(args: AddressLookupTableAccountArgs) {
+    this.key = args.key;
+    this.state = args.state;
+  }
+
+  isActive(): boolean {
+    const U64_MAX = 2n ** 64n - 1n;
+    return this.state.deactivationSlot === U64_MAX;
+  }
+
+  static deserialize(accountData: Uint8Array): AddressLookupTableState {
+    const meta = decodeData(LookupTableMetaLayout, accountData);
+
+    const serializedAddressesLen = accountData.length - LOOKUP_TABLE_META_SIZE;
+    assert(serializedAddressesLen >= 0, 'lookup table is invalid');
+    assert(serializedAddressesLen % 32 === 0, 'lookup table is invalid');
+
+    const numSerializedAddresses = serializedAddressesLen / 32;
+    const {addresses} = BufferLayout.struct<{addresses: Array<Uint8Array>}>([
+      BufferLayout.seq(Layout.publicKey(), numSerializedAddresses, 'addresses'),
+    ]).decode(accountData.slice(LOOKUP_TABLE_META_SIZE));
+
+    return {
+      deactivationSlot: meta.deactivationSlot,
+      lastExtendedSlot: meta.lastExtendedSlot,
+      lastExtendedSlotStartIndex: meta.lastExtendedStartIndex,
+      authority:
+        meta.authority.length !== 0
+          ? new PublicKey(meta.authority[0])
+          : undefined,
+      addresses: addresses.map(address => new PublicKey(address)),
+    };
+  }
+}
+
+const LookupTableMetaLayout = {
+  index: 1,
+  layout: BufferLayout.struct<{
+    typeIndex: number;
+    deactivationSlot: bigint;
+    lastExtendedSlot: number;
+    lastExtendedStartIndex: number;
+    authority: Array<Uint8Array>;
+  }>([
+    BufferLayout.u32('typeIndex'),
+    u64('deactivationSlot'),
+    BufferLayout.nu64('lastExtendedSlot'),
+    BufferLayout.u8('lastExtendedStartIndex'),
+    BufferLayout.u8(), // option
+    BufferLayout.seq(
+      Layout.publicKey(),
+      BufferLayout.offset(BufferLayout.u8(), -1),
+      'authority',
+    ),
+  ]),
+};

package/src/{compute-budget.ts → programs/compute-budget.ts}

@@ -5,10 +5,10 @@ import {
   decodeData,
   InstructionType,
   IInstructionInputData,
-} from './instruction';
-import {PublicKey} from './publickey';
-import {TransactionInstruction} from './transaction';
-import {u64} from './util/bigint';
+} from '../instruction';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import {u64} from '../utils/bigint';
 
 /**
  * Compute Budget Instruction class

package/src/{ed25519-program.ts → programs/ed25519.ts}

@@ -2,10 +2,10 @@ import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 import nacl from 'tweetnacl';
 
-import {Keypair} from './keypair';
-import {PublicKey} from './publickey';
-import {TransactionInstruction} from './transaction';
-import assert from './util/assert';
+import {Keypair} from '../keypair';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
 
 const PRIVATE_KEY_BYTES = 64;
 const PUBLIC_KEY_BYTES = 32;

package/src/programs/index.ts

@@ -0,0 +1,7 @@
+export * from './address-lookup-table';
+export * from './compute-budget';
+export * from './ed25519';
+export * from './secp256k1';
+export * from './stake';
+export * from './system';
+export * from './vote';

package/src/{secp256k1-program.ts → programs/secp256k1.ts}

@@ -3,10 +3,10 @@ import * as BufferLayout from '@solana/buffer-layout';
 import secp256k1 from 'secp256k1';
 import sha3 from 'js-sha3';
 
-import {PublicKey} from './publickey';
-import {TransactionInstruction} from './transaction';
-import assert from './util/assert';
-import {toBuffer} from './util/to-buffer';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
+import {toBuffer} from '../utils/to-buffer';
 
 const {publicKeyCreate, ecdsaSign} = secp256k1;
 

package/src/{stake-program.ts → programs/stake.ts}

@@ -5,17 +5,17 @@ import {
   decodeData,
   InstructionType,
   IInstructionInputData,
-} from './instruction';
-import * as Layout from './layout';
-import {PublicKey} from './publickey';
-import {SystemProgram} from './system-program';
+} from '../instruction';
+import * as Layout from '../layout';
+import {PublicKey} from '../publickey';
+import {SystemProgram} from './system';
 import {
   SYSVAR_CLOCK_PUBKEY,
   SYSVAR_RENT_PUBKEY,
   SYSVAR_STAKE_HISTORY_PUBKEY,
-} from './sysvar';
-import {Transaction, TransactionInstruction} from './transaction';
-import {toBuffer} from './util/to-buffer';
+} from '../sysvar';
+import {Transaction, TransactionInstruction} from '../transaction';
+import {toBuffer} from '../utils/to-buffer';
 
 /**
  * Address of the stake config account which configures the rate

package/src/{system-program.ts → programs/system.ts}

@@ -5,14 +5,14 @@ import {
   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';
+} 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 '../utils/to-buffer';
+import {u64} from '../utils/bigint';
 
 /**
  * Create account system transaction params

package/src/{vote-program.ts → programs/vote.ts}

@@ -5,13 +5,13 @@ import {
   decodeData,
   InstructionType,
   IInstructionInputData,
-} from './instruction';
-import * as Layout from './layout';
-import {PublicKey} from './publickey';
-import {SystemProgram} from './system-program';
-import {SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY} from './sysvar';
-import {Transaction, TransactionInstruction} from './transaction';
-import {toBuffer} from './util/to-buffer';
+} from '../instruction';
+import * as Layout from '../layout';
+import {PublicKey} from '../publickey';
+import {SystemProgram} from './system';
+import {SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY} from '../sysvar';
+import {Transaction, TransactionInstruction} from '../transaction';
+import {toBuffer} from '../utils/to-buffer';
 
 /**
  * Vote account info
@@ -410,4 +410,25 @@ export class VoteProgram {
       data,
     });
   }
+
+  /**
+   * Generate a transaction to withdraw safely from a Vote account.
+   *
+   * This function was created as a safeguard for vote accounts running validators, `safeWithdraw`
+   * checks that the withdraw amount will not exceed the specified balance while leaving enough left
+   * to cover rent. If you wish to close the vote account by withdrawing the full amount, call the
+   * `withdraw` method directly.
+   */
+  static safeWithdraw(
+    params: WithdrawFromVoteAccountParams,
+    currentVoteAccountBalance: number,
+    rentExemptMinimum: number,
+  ): Transaction {
+    if (params.lamports > currentVoteAccountBalance - rentExemptMinimum) {
+      throw new Error(
+        'Withdraw will leave vote account with insuffcient funds.',
+      );
+    }
+    return VoteProgram.withdraw(params);
+  }
 }

package/src/publickey.ts

@@ -4,14 +4,19 @@ import {Buffer} from 'buffer';
 import nacl from 'tweetnacl';
 import {sha256} from '@ethersproject/sha2';
 
-import {Struct, SOLANA_SCHEMA} from './util/borsh-schema';
-import {toBuffer} from './util/to-buffer';
+import {Struct, SOLANA_SCHEMA} from './utils/borsh-schema';
+import {toBuffer} from './utils/to-buffer';
 
 /**
  * Maximum length of derived pubkey seed
  */
 export const MAX_SEED_LENGTH = 32;
 
+/**
+ * Size of public key in bytes
+ */
+export const PUBLIC_KEY_LENGTH = 32;
+
 /**
  * Value to be converted into public key
  */
@@ -54,7 +59,7 @@ export class PublicKey extends Struct {
       if (typeof value === 'string') {
         // assume base 58 encoding by default
         const decoded = bs58.decode(value);
-        if (decoded.length != 32) {
+        if (decoded.length != PUBLIC_KEY_LENGTH) {
           throw new Error(`Invalid public key input`);
         }
         this._bn = new BN(decoded);
@@ -103,7 +108,7 @@ export class PublicKey extends Struct {
    */
   toBuffer(): Buffer {
     const b = this._bn.toArrayLike(Buffer);
-    if (b.length === 32) {
+    if (b.length === PUBLIC_KEY_LENGTH) {
       return b;
     }
 

package/src/{transaction-constants.ts → transaction/constants.ts}

@@ -7,4 +7,6 @@
  */
 export const PACKET_DATA_SIZE = 1280 - 40 - 8;
 
+export const VERSION_PREFIX_MASK = 0x7f;
+
 export const SIGNATURE_LENGTH_IN_BYTES = 64;

package/src/transaction/index.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './expiry-custom-errors';
+export * from './legacy';
+export * from './versioned';