@stellar/stellar-base 12.1.1 → 13.0.0

package/types/next.d.ts

@@ -1,4 +1,5 @@
-// Automatically generated on 2023-10-16T10:48:00-08:00
+// Automatically generated by xdrgen on 2024-09-12T11:09:00-08:00
+// DO NOT EDIT or your changes may be overwritten
 import { Operation } from './index';
 
 export {};
@@ -88,7 +89,7 @@ export namespace xdr {
     unsigned: boolean;
 
     constructor(
-      values: string | bigint | number | Array<string | bigint | number>,
+      values: string | bigint | number | (string | bigint | number)[],
     );
 
     toXDR(format?: 'raw'): Buffer;
@@ -132,7 +133,7 @@ export namespace xdr {
     unsigned: boolean;
 
     constructor(
-      values: string | bigint | number | Array<string | bigint | number>,
+      values: string | bigint | number | (string | bigint | number)[],
     );
 
     toXDR(format?: 'raw'): Buffer;
@@ -487,6 +488,71 @@ export namespace xdr {
     static envelopeTypeSorobanAuthorization(): EnvelopeType;
   }
 
+  class BucketListType {
+    readonly name: 'live' | 'hotArchive' | 'coldArchive';
+
+    readonly value: 0 | 1 | 2;
+
+    static live(): BucketListType;
+
+    static hotArchive(): BucketListType;
+
+    static coldArchive(): BucketListType;
+  }
+
+  class BucketEntryType {
+    readonly name: 'metaentry' | 'liveentry' | 'deadentry' | 'initentry';
+
+    readonly value: -1 | 0 | 1 | 2;
+
+    static metaentry(): BucketEntryType;
+
+    static liveentry(): BucketEntryType;
+
+    static deadentry(): BucketEntryType;
+
+    static initentry(): BucketEntryType;
+  }
+
+  class HotArchiveBucketEntryType {
+    readonly name:
+      | 'hotArchiveMetaentry'
+      | 'hotArchiveArchived'
+      | 'hotArchiveLive'
+      | 'hotArchiveDeleted';
+
+    readonly value: -1 | 0 | 1 | 2;
+
+    static hotArchiveMetaentry(): HotArchiveBucketEntryType;
+
+    static hotArchiveArchived(): HotArchiveBucketEntryType;
+
+    static hotArchiveLive(): HotArchiveBucketEntryType;
+
+    static hotArchiveDeleted(): HotArchiveBucketEntryType;
+  }
+
+  class ColdArchiveBucketEntryType {
+    readonly name:
+      | 'coldArchiveMetaentry'
+      | 'coldArchiveArchivedLeaf'
+      | 'coldArchiveDeletedLeaf'
+      | 'coldArchiveBoundaryLeaf'
+      | 'coldArchiveHash';
+
+    readonly value: -1 | 0 | 1 | 2 | 3;
+
+    static coldArchiveMetaentry(): ColdArchiveBucketEntryType;
+
+    static coldArchiveArchivedLeaf(): ColdArchiveBucketEntryType;
+
+    static coldArchiveDeletedLeaf(): ColdArchiveBucketEntryType;
+
+    static coldArchiveBoundaryLeaf(): ColdArchiveBucketEntryType;
+
+    static coldArchiveHash(): ColdArchiveBucketEntryType;
+  }
+
   class StellarValueType {
     readonly name: 'stellarValueBasic' | 'stellarValueSigned';
 
@@ -539,20 +605,6 @@ export namespace xdr {
     static ledgerUpgradeMaxSorobanTxSetSize(): LedgerUpgradeType;
   }
 
-  class BucketEntryType {
-    readonly name: 'metaentry' | 'liveentry' | 'deadentry' | 'initentry';
-
-    readonly value: -1 | 0 | 1 | 2;
-
-    static metaentry(): BucketEntryType;
-
-    static liveentry(): BucketEntryType;
-
-    static deadentry(): BucketEntryType;
-
-    static initentry(): BucketEntryType;
-  }
-
   class TxSetComponentType {
     readonly name: 'txsetCompTxsMaybeDiscountedFee';
 
@@ -638,7 +690,11 @@ export namespace xdr {
       | 'sendMore'
       | 'sendMoreExtended'
       | 'floodAdvert'
-      | 'floodDemand';
+      | 'floodDemand'
+      | 'timeSlicedSurveyRequest'
+      | 'timeSlicedSurveyResponse'
+      | 'timeSlicedSurveyStartCollecting'
+      | 'timeSlicedSurveyStopCollecting';
 
     readonly value:
       | 0
@@ -660,7 +716,11 @@ export namespace xdr {
       | 16
       | 20
       | 18
-      | 19;
+      | 19
+      | 21
+      | 22
+      | 23
+      | 24;
 
     static errorMsg(): MessageType;
 
@@ -701,24 +761,39 @@ export namespace xdr {
     static floodAdvert(): MessageType;
 
     static floodDemand(): MessageType;
+
+    static timeSlicedSurveyRequest(): MessageType;
+
+    static timeSlicedSurveyResponse(): MessageType;
+
+    static timeSlicedSurveyStartCollecting(): MessageType;
+
+    static timeSlicedSurveyStopCollecting(): MessageType;
   }
 
   class SurveyMessageCommandType {
-    readonly name: 'surveyTopology';
+    readonly name: 'surveyTopology' | 'timeSlicedSurveyTopology';
 
-    readonly value: 0;
+    readonly value: 0 | 1;
 
     static surveyTopology(): SurveyMessageCommandType;
+
+    static timeSlicedSurveyTopology(): SurveyMessageCommandType;
   }
 
   class SurveyMessageResponseType {
-    readonly name: 'surveyTopologyResponseV0' | 'surveyTopologyResponseV1';
+    readonly name:
+      | 'surveyTopologyResponseV0'
+      | 'surveyTopologyResponseV1'
+      | 'surveyTopologyResponseV2';
 
-    readonly value: 0 | 1;
+    readonly value: 0 | 1 | 2;
 
     static surveyTopologyResponseV0(): SurveyMessageResponseType;
 
     static surveyTopologyResponseV1(): SurveyMessageResponseType;
+
+    static surveyTopologyResponseV2(): SurveyMessageResponseType;
   }
 
   class OperationType {
@@ -849,15 +924,18 @@ export namespace xdr {
     readonly name:
       | 'hostFunctionTypeInvokeContract'
       | 'hostFunctionTypeCreateContract'
-      | 'hostFunctionTypeUploadContractWasm';
+      | 'hostFunctionTypeUploadContractWasm'
+      | 'hostFunctionTypeCreateContractV2';
 
-    readonly value: 0 | 1 | 2;
+    readonly value: 0 | 1 | 2 | 3;
 
     static hostFunctionTypeInvokeContract(): HostFunctionType;
 
     static hostFunctionTypeCreateContract(): HostFunctionType;
 
     static hostFunctionTypeUploadContractWasm(): HostFunctionType;
+
+    static hostFunctionTypeCreateContractV2(): HostFunctionType;
   }
 
   class ContractIdPreimageType {
@@ -875,13 +953,16 @@ export namespace xdr {
   class SorobanAuthorizedFunctionType {
     readonly name:
       | 'sorobanAuthorizedFunctionTypeContractFn'
-      | 'sorobanAuthorizedFunctionTypeCreateContractHostFn';
+      | 'sorobanAuthorizedFunctionTypeCreateContractHostFn'
+      | 'sorobanAuthorizedFunctionTypeCreateContractV2HostFn';
 
-    readonly value: 0 | 1;
+    readonly value: 0 | 1 | 2;
 
     static sorobanAuthorizedFunctionTypeContractFn(): SorobanAuthorizedFunctionType;
 
     static sorobanAuthorizedFunctionTypeCreateContractHostFn(): SorobanAuthorizedFunctionType;
+
+    static sorobanAuthorizedFunctionTypeCreateContractV2HostFn(): SorobanAuthorizedFunctionType;
   }
 
   class SorobanCredentialsType {
@@ -929,6 +1010,16 @@ export namespace xdr {
     static precondV2(): PreconditionType;
   }
 
+  class ArchivalProofType {
+    readonly name: 'existence' | 'nonexistence';
+
+    readonly value: 0 | 1;
+
+    static existence(): ArchivalProofType;
+
+    static nonexistence(): ArchivalProofType;
+  }
+
   class ClaimAtomType {
     readonly name:
       | 'claimAtomTypeV0'
@@ -1853,6 +1944,21 @@ export namespace xdr {
     static signerKeyTypeEd25519SignedPayload(): SignerKeyType;
   }
 
+  class BinaryFuseFilterType {
+    readonly name:
+      | 'binaryFuseFilter8Bit'
+      | 'binaryFuseFilter16Bit'
+      | 'binaryFuseFilter32Bit';
+
+    readonly value: 0 | 1 | 2;
+
+    static binaryFuseFilter8Bit(): BinaryFuseFilterType;
+
+    static binaryFuseFilter16Bit(): BinaryFuseFilterType;
+
+    static binaryFuseFilter32Bit(): BinaryFuseFilterType;
+  }
+
   class ScValType {
     readonly name:
       | 'scvBool'
@@ -2238,7 +2344,32 @@ export namespace xdr {
       | 'instantiateWasmExports'
       | 'instantiateWasmDataSegmentBytes'
       | 'sec1DecodePointUncompressed'
-      | 'verifyEcdsaSecp256r1Sig';
+      | 'verifyEcdsaSecp256r1Sig'
+      | 'bls12381EncodeFp'
+      | 'bls12381DecodeFp'
+      | 'bls12381G1CheckPointOnCurve'
+      | 'bls12381G1CheckPointInSubgroup'
+      | 'bls12381G2CheckPointOnCurve'
+      | 'bls12381G2CheckPointInSubgroup'
+      | 'bls12381G1ProjectiveToAffine'
+      | 'bls12381G2ProjectiveToAffine'
+      | 'bls12381G1Add'
+      | 'bls12381G1Mul'
+      | 'bls12381G1Msm'
+      | 'bls12381MapFpToG1'
+      | 'bls12381HashToG1'
+      | 'bls12381G2Add'
+      | 'bls12381G2Mul'
+      | 'bls12381G2Msm'
+      | 'bls12381MapFp2ToG2'
+      | 'bls12381HashToG2'
+      | 'bls12381Pairing'
+      | 'bls12381FrFromU256'
+      | 'bls12381FrToU256'
+      | 'bls12381FrAddSub'
+      | 'bls12381FrMul'
+      | 'bls12381FrPow'
+      | 'bls12381FrInv';
 
     readonly value:
       | 0
@@ -2285,7 +2416,32 @@ export namespace xdr {
       | 41
       | 42
       | 43
-      | 44;
+      | 44
+      | 45
+      | 46
+      | 47
+      | 48
+      | 49
+      | 50
+      | 51
+      | 52
+      | 53
+      | 54
+      | 55
+      | 56
+      | 57
+      | 58
+      | 59
+      | 60
+      | 61
+      | 62
+      | 63
+      | 64
+      | 65
+      | 66
+      | 67
+      | 68
+      | 69;
 
     static wasmInsnExec(): ContractCostType;
 
@@ -2376,6 +2532,56 @@ export namespace xdr {
     static sec1DecodePointUncompressed(): ContractCostType;
 
     static verifyEcdsaSecp256r1Sig(): ContractCostType;
+
+    static bls12381EncodeFp(): ContractCostType;
+
+    static bls12381DecodeFp(): ContractCostType;
+
+    static bls12381G1CheckPointOnCurve(): ContractCostType;
+
+    static bls12381G1CheckPointInSubgroup(): ContractCostType;
+
+    static bls12381G2CheckPointOnCurve(): ContractCostType;
+
+    static bls12381G2CheckPointInSubgroup(): ContractCostType;
+
+    static bls12381G1ProjectiveToAffine(): ContractCostType;
+
+    static bls12381G2ProjectiveToAffine(): ContractCostType;
+
+    static bls12381G1Add(): ContractCostType;
+
+    static bls12381G1Mul(): ContractCostType;
+
+    static bls12381G1Msm(): ContractCostType;
+
+    static bls12381MapFpToG1(): ContractCostType;
+
+    static bls12381HashToG1(): ContractCostType;
+
+    static bls12381G2Add(): ContractCostType;
+
+    static bls12381G2Mul(): ContractCostType;
+
+    static bls12381G2Msm(): ContractCostType;
+
+    static bls12381MapFp2ToG2(): ContractCostType;
+
+    static bls12381HashToG2(): ContractCostType;
+
+    static bls12381Pairing(): ContractCostType;
+
+    static bls12381FrFromU256(): ContractCostType;
+
+    static bls12381FrToU256(): ContractCostType;
+
+    static bls12381FrAddSub(): ContractCostType;
+
+    static bls12381FrMul(): ContractCostType;
+
+    static bls12381FrPow(): ContractCostType;
+
+    static bls12381FrInv(): ContractCostType;
   }
 
   class ConfigSettingId {
@@ -2393,9 +2599,25 @@ export namespace xdr {
       | 'configSettingStateArchival'
       | 'configSettingContractExecutionLanes'
       | 'configSettingBucketlistSizeWindow'
-      | 'configSettingEvictionIterator';
+      | 'configSettingEvictionIterator'
+      | 'configSettingContractParallelComputeV0';
 
-    readonly value: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13;
+    readonly value:
+      | 0
+      | 1
+      | 2
+      | 3
+      | 4
+      | 5
+      | 6
+      | 7
+      | 8
+      | 9
+      | 10
+      | 11
+      | 12
+      | 13
+      | 14;
 
     static configSettingContractMaxSizeBytes(): ConfigSettingId;
 
@@ -2424,6 +2646,8 @@ export namespace xdr {
     static configSettingBucketlistSizeWindow(): ConfigSettingId;
 
     static configSettingEvictionIterator(): ConfigSettingId;
+
+    static configSettingContractParallelComputeV0(): ConfigSettingId;
   }
 
   const Value: VarOpaque;
@@ -2448,16 +2672,24 @@ export namespace xdr {
 
   const UpgradeType: VarOpaque;
 
+  const TxExecutionThread: XDRArray<TransactionEnvelope>;
+
+  const ParallelTxExecutionStage: XDRArray<TransactionEnvelope[]>;
+
   const LedgerEntryChanges: XDRArray<LedgerEntryChange>;
 
   const EncryptedBody: VarOpaque;
 
   const PeerStatList: XDRArray<PeerStats>;
 
+  const TimeSlicedPeerDataList: XDRArray<TimeSlicedPeerData>;
+
   const TxAdvertVector: XDRArray<Hash>;
 
   const TxDemandVector: XDRArray<Hash>;
 
+  const ProofLevel: XDRArray<ArchivalProofNode>;
+
   const Hash: Opaque;
 
   const Uint256: Opaque;
@@ -4068,6 +4300,160 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class BucketMetadata {
+    constructor(attributes: { ledgerVersion: number; ext: BucketMetadataExt });
+
+    ledgerVersion(value?: number): number;
+
+    ext(value?: BucketMetadataExt): BucketMetadataExt;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): BucketMetadata;
+
+    static write(value: BucketMetadata, io: Buffer): void;
+
+    static isValid(value: BucketMetadata): boolean;
+
+    static toXDR(value: BucketMetadata): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): BucketMetadata;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): BucketMetadata;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ColdArchiveArchivedLeaf {
+    constructor(attributes: { index: number; archivedEntry: LedgerEntry });
+
+    index(value?: number): number;
+
+    archivedEntry(value?: LedgerEntry): LedgerEntry;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ColdArchiveArchivedLeaf;
+
+    static write(value: ColdArchiveArchivedLeaf, io: Buffer): void;
+
+    static isValid(value: ColdArchiveArchivedLeaf): boolean;
+
+    static toXDR(value: ColdArchiveArchivedLeaf): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveArchivedLeaf;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveArchivedLeaf;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ColdArchiveDeletedLeaf {
+    constructor(attributes: { index: number; deletedKey: LedgerKey });
+
+    index(value?: number): number;
+
+    deletedKey(value?: LedgerKey): LedgerKey;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ColdArchiveDeletedLeaf;
+
+    static write(value: ColdArchiveDeletedLeaf, io: Buffer): void;
+
+    static isValid(value: ColdArchiveDeletedLeaf): boolean;
+
+    static toXDR(value: ColdArchiveDeletedLeaf): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveDeletedLeaf;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveDeletedLeaf;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ColdArchiveBoundaryLeaf {
+    constructor(attributes: { index: number; isLowerBound: boolean });
+
+    index(value?: number): number;
+
+    isLowerBound(value?: boolean): boolean;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ColdArchiveBoundaryLeaf;
+
+    static write(value: ColdArchiveBoundaryLeaf, io: Buffer): void;
+
+    static isValid(value: ColdArchiveBoundaryLeaf): boolean;
+
+    static toXDR(value: ColdArchiveBoundaryLeaf): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveBoundaryLeaf;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveBoundaryLeaf;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ColdArchiveHashEntry {
+    constructor(attributes: { index: number; level: number; hash: Buffer });
+
+    index(value?: number): number;
+
+    level(value?: number): number;
+
+    hash(value?: Buffer): Buffer;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ColdArchiveHashEntry;
+
+    static write(value: ColdArchiveHashEntry, io: Buffer): void;
+
+    static isValid(value: ColdArchiveHashEntry): boolean;
+
+    static toXDR(value: ColdArchiveHashEntry): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveHashEntry;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveHashEntry;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class LedgerCloseValueSignature {
     constructor(attributes: { nodeId: NodeId; signature: Buffer });
 
@@ -4294,28 +4680,36 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class BucketMetadata {
-    constructor(attributes: { ledgerVersion: number; ext: BucketMetadataExt });
+  class ParallelTxsComponent {
+    constructor(attributes: {
+      baseFee: null | Int64;
+      executionStages: TransactionEnvelope[][][];
+    });
 
-    ledgerVersion(value?: number): number;
+    baseFee(value?: null | Int64): null | Int64;
 
-    ext(value?: BucketMetadataExt): BucketMetadataExt;
+    executionStages(
+      value?: TransactionEnvelope[][][],
+    ): TransactionEnvelope[][][];
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): BucketMetadata;
+    static read(io: Buffer): ParallelTxsComponent;
 
-    static write(value: BucketMetadata, io: Buffer): void;
+    static write(value: ParallelTxsComponent, io: Buffer): void;
 
-    static isValid(value: BucketMetadata): boolean;
+    static isValid(value: ParallelTxsComponent): boolean;
 
-    static toXDR(value: BucketMetadata): Buffer;
+    static toXDR(value: ParallelTxsComponent): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): BucketMetadata;
+    static fromXDR(input: Buffer, format?: 'raw'): ParallelTxsComponent;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): BucketMetadata;
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ParallelTxsComponent;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
@@ -5449,6 +5843,178 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class TimeSlicedSurveyStartCollectingMessage {
+    constructor(attributes: {
+      surveyorId: NodeId;
+      nonce: number;
+      ledgerNum: number;
+    });
+
+    surveyorId(value?: NodeId): NodeId;
+
+    nonce(value?: number): number;
+
+    ledgerNum(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedSurveyStartCollectingMessage;
+
+    static write(
+      value: TimeSlicedSurveyStartCollectingMessage,
+      io: Buffer,
+    ): void;
+
+    static isValid(value: TimeSlicedSurveyStartCollectingMessage): boolean;
+
+    static toXDR(value: TimeSlicedSurveyStartCollectingMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): TimeSlicedSurveyStartCollectingMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): TimeSlicedSurveyStartCollectingMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class SignedTimeSlicedSurveyStartCollectingMessage {
+    constructor(attributes: {
+      signature: Buffer;
+      startCollecting: TimeSlicedSurveyStartCollectingMessage;
+    });
+
+    signature(value?: Buffer): Buffer;
+
+    startCollecting(
+      value?: TimeSlicedSurveyStartCollectingMessage,
+    ): TimeSlicedSurveyStartCollectingMessage;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SignedTimeSlicedSurveyStartCollectingMessage;
+
+    static write(
+      value: SignedTimeSlicedSurveyStartCollectingMessage,
+      io: Buffer,
+    ): void;
+
+    static isValid(
+      value: SignedTimeSlicedSurveyStartCollectingMessage,
+    ): boolean;
+
+    static toXDR(value: SignedTimeSlicedSurveyStartCollectingMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): SignedTimeSlicedSurveyStartCollectingMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SignedTimeSlicedSurveyStartCollectingMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class TimeSlicedSurveyStopCollectingMessage {
+    constructor(attributes: {
+      surveyorId: NodeId;
+      nonce: number;
+      ledgerNum: number;
+    });
+
+    surveyorId(value?: NodeId): NodeId;
+
+    nonce(value?: number): number;
+
+    ledgerNum(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedSurveyStopCollectingMessage;
+
+    static write(
+      value: TimeSlicedSurveyStopCollectingMessage,
+      io: Buffer,
+    ): void;
+
+    static isValid(value: TimeSlicedSurveyStopCollectingMessage): boolean;
+
+    static toXDR(value: TimeSlicedSurveyStopCollectingMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): TimeSlicedSurveyStopCollectingMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): TimeSlicedSurveyStopCollectingMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class SignedTimeSlicedSurveyStopCollectingMessage {
+    constructor(attributes: {
+      signature: Buffer;
+      stopCollecting: TimeSlicedSurveyStopCollectingMessage;
+    });
+
+    signature(value?: Buffer): Buffer;
+
+    stopCollecting(
+      value?: TimeSlicedSurveyStopCollectingMessage,
+    ): TimeSlicedSurveyStopCollectingMessage;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SignedTimeSlicedSurveyStopCollectingMessage;
+
+    static write(
+      value: SignedTimeSlicedSurveyStopCollectingMessage,
+      io: Buffer,
+    ): void;
+
+    static isValid(value: SignedTimeSlicedSurveyStopCollectingMessage): boolean;
+
+    static toXDR(value: SignedTimeSlicedSurveyStopCollectingMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): SignedTimeSlicedSurveyStopCollectingMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SignedTimeSlicedSurveyStopCollectingMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class SurveyRequestMessage {
     constructor(attributes: {
       surveyorPeerId: NodeId;
@@ -5492,6 +6058,49 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class TimeSlicedSurveyRequestMessage {
+    constructor(attributes: {
+      request: SurveyRequestMessage;
+      nonce: number;
+      inboundPeersIndex: number;
+      outboundPeersIndex: number;
+    });
+
+    request(value?: SurveyRequestMessage): SurveyRequestMessage;
+
+    nonce(value?: number): number;
+
+    inboundPeersIndex(value?: number): number;
+
+    outboundPeersIndex(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedSurveyRequestMessage;
+
+    static write(value: TimeSlicedSurveyRequestMessage, io: Buffer): void;
+
+    static isValid(value: TimeSlicedSurveyRequestMessage): boolean;
+
+    static toXDR(value: TimeSlicedSurveyRequestMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): TimeSlicedSurveyRequestMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): TimeSlicedSurveyRequestMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class SignedSurveyRequestMessage {
     constructor(attributes: {
       requestSignature: Buffer;
@@ -5526,6 +6135,45 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class SignedTimeSlicedSurveyRequestMessage {
+    constructor(attributes: {
+      requestSignature: Buffer;
+      request: TimeSlicedSurveyRequestMessage;
+    });
+
+    requestSignature(value?: Buffer): Buffer;
+
+    request(
+      value?: TimeSlicedSurveyRequestMessage,
+    ): TimeSlicedSurveyRequestMessage;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SignedTimeSlicedSurveyRequestMessage;
+
+    static write(value: SignedTimeSlicedSurveyRequestMessage, io: Buffer): void;
+
+    static isValid(value: SignedTimeSlicedSurveyRequestMessage): boolean;
+
+    static toXDR(value: SignedTimeSlicedSurveyRequestMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): SignedTimeSlicedSurveyRequestMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SignedTimeSlicedSurveyRequestMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class SurveyResponseMessage {
     constructor(attributes: {
       surveyorPeerId: NodeId;
@@ -5569,6 +6217,40 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class TimeSlicedSurveyResponseMessage {
+    constructor(attributes: { response: SurveyResponseMessage; nonce: number });
+
+    response(value?: SurveyResponseMessage): SurveyResponseMessage;
+
+    nonce(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedSurveyResponseMessage;
+
+    static write(value: TimeSlicedSurveyResponseMessage, io: Buffer): void;
+
+    static isValid(value: TimeSlicedSurveyResponseMessage): boolean;
+
+    static toXDR(value: TimeSlicedSurveyResponseMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): TimeSlicedSurveyResponseMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): TimeSlicedSurveyResponseMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class SignedSurveyResponseMessage {
     constructor(attributes: {
       responseSignature: Buffer;
@@ -5603,6 +6285,48 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class SignedTimeSlicedSurveyResponseMessage {
+    constructor(attributes: {
+      responseSignature: Buffer;
+      response: TimeSlicedSurveyResponseMessage;
+    });
+
+    responseSignature(value?: Buffer): Buffer;
+
+    response(
+      value?: TimeSlicedSurveyResponseMessage,
+    ): TimeSlicedSurveyResponseMessage;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SignedTimeSlicedSurveyResponseMessage;
+
+    static write(
+      value: SignedTimeSlicedSurveyResponseMessage,
+      io: Buffer,
+    ): void;
+
+    static isValid(value: SignedTimeSlicedSurveyResponseMessage): boolean;
+
+    static toXDR(value: SignedTimeSlicedSurveyResponseMessage): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): SignedTimeSlicedSurveyResponseMessage;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SignedTimeSlicedSurveyResponseMessage;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class PeerStats {
     constructor(attributes: {
       id: NodeId;
@@ -5673,6 +6397,89 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class TimeSlicedNodeData {
+    constructor(attributes: {
+      addedAuthenticatedPeers: number;
+      droppedAuthenticatedPeers: number;
+      totalInboundPeerCount: number;
+      totalOutboundPeerCount: number;
+      p75ScpFirstToSelfLatencyMs: number;
+      p75ScpSelfToOtherLatencyMs: number;
+      lostSyncCount: number;
+      isValidator: boolean;
+      maxInboundPeerCount: number;
+      maxOutboundPeerCount: number;
+    });
+
+    addedAuthenticatedPeers(value?: number): number;
+
+    droppedAuthenticatedPeers(value?: number): number;
+
+    totalInboundPeerCount(value?: number): number;
+
+    totalOutboundPeerCount(value?: number): number;
+
+    p75ScpFirstToSelfLatencyMs(value?: number): number;
+
+    p75ScpSelfToOtherLatencyMs(value?: number): number;
+
+    lostSyncCount(value?: number): number;
+
+    isValidator(value?: boolean): boolean;
+
+    maxInboundPeerCount(value?: number): number;
+
+    maxOutboundPeerCount(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedNodeData;
+
+    static write(value: TimeSlicedNodeData, io: Buffer): void;
+
+    static isValid(value: TimeSlicedNodeData): boolean;
+
+    static toXDR(value: TimeSlicedNodeData): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): TimeSlicedNodeData;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): TimeSlicedNodeData;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class TimeSlicedPeerData {
+    constructor(attributes: { peerStats: PeerStats; averageLatencyMs: number });
+
+    peerStats(value?: PeerStats): PeerStats;
+
+    averageLatencyMs(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TimeSlicedPeerData;
+
+    static write(value: TimeSlicedPeerData, io: Buffer): void;
+
+    static isValid(value: TimeSlicedPeerData): boolean;
+
+    static toXDR(value: TimeSlicedPeerData): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): TimeSlicedPeerData;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): TimeSlicedPeerData;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class TopologyResponseBodyV0 {
     constructor(attributes: {
       inboundPeers: PeerStats[];
@@ -5759,6 +6566,43 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class TopologyResponseBodyV2 {
+    constructor(attributes: {
+      inboundPeers: TimeSlicedPeerData[];
+      outboundPeers: TimeSlicedPeerData[];
+      nodeData: TimeSlicedNodeData;
+    });
+
+    inboundPeers(value?: TimeSlicedPeerData[]): TimeSlicedPeerData[];
+
+    outboundPeers(value?: TimeSlicedPeerData[]): TimeSlicedPeerData[];
+
+    nodeData(value?: TimeSlicedNodeData): TimeSlicedNodeData;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): TopologyResponseBodyV2;
+
+    static write(value: TopologyResponseBodyV2, io: Buffer): void;
+
+    static isValid(value: TopologyResponseBodyV2): boolean;
+
+    static toXDR(value: TopologyResponseBodyV2): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): TopologyResponseBodyV2;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): TopologyResponseBodyV2;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class FloodAdvert {
     constructor(attributes: { txHashes: Hash[] });
 
@@ -6732,6 +7576,43 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class CreateContractArgsV2 {
+    constructor(attributes: {
+      contractIdPreimage: ContractIdPreimage;
+      executable: ContractExecutable;
+      constructorArgs: ScVal[];
+    });
+
+    contractIdPreimage(value?: ContractIdPreimage): ContractIdPreimage;
+
+    executable(value?: ContractExecutable): ContractExecutable;
+
+    constructorArgs(value?: ScVal[]): ScVal[];
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): CreateContractArgsV2;
+
+    static write(value: CreateContractArgsV2, io: Buffer): void;
+
+    static isValid(value: CreateContractArgsV2): boolean;
+
+    static toXDR(value: CreateContractArgsV2): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): CreateContractArgsV2;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): CreateContractArgsV2;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class InvokeContractArgs {
     constructor(attributes: {
       contractAddress: ScAddress;
@@ -6969,6 +7850,37 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class Operation {
+    constructor(attributes: {
+      sourceAccount: null | MuxedAccount;
+      body: OperationBody;
+    });
+
+    sourceAccount(value?: null | MuxedAccount): null | MuxedAccount;
+
+    body(value?: OperationBody): OperationBody;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): Operation;
+
+    static write(value: Operation, io: Buffer): void;
+
+    static isValid(value: Operation): boolean;
+
+    static toXDR(value: Operation): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): Operation;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): Operation;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class HashIdPreimageOperationId {
     constructor(attributes: {
       sourceAccount: AccountId;
@@ -7232,23 +8144,152 @@ export namespace xdr {
 
     readOnly(value?: LedgerKey[]): LedgerKey[];
 
-    readWrite(value?: LedgerKey[]): LedgerKey[];
+    readWrite(value?: LedgerKey[]): LedgerKey[];
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): LedgerFootprint;
+
+    static write(value: LedgerFootprint, io: Buffer): void;
+
+    static isValid(value: LedgerFootprint): boolean;
+
+    static toXDR(value: LedgerFootprint): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): LedgerFootprint;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerFootprint;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ArchivalProofNode {
+    constructor(attributes: { index: number; hash: Buffer });
+
+    index(value?: number): number;
+
+    hash(value?: Buffer): Buffer;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ArchivalProofNode;
+
+    static write(value: ArchivalProofNode, io: Buffer): void;
+
+    static isValid(value: ArchivalProofNode): boolean;
+
+    static toXDR(value: ArchivalProofNode): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ArchivalProofNode;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ArchivalProofNode;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class NonexistenceProofBody {
+    constructor(attributes: {
+      entriesToProve: ColdArchiveBucketEntry[];
+      proofLevels: ArchivalProofNode[][];
+    });
+
+    entriesToProve(value?: ColdArchiveBucketEntry[]): ColdArchiveBucketEntry[];
+
+    proofLevels(value?: ArchivalProofNode[][]): ArchivalProofNode[][];
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): NonexistenceProofBody;
+
+    static write(value: NonexistenceProofBody, io: Buffer): void;
+
+    static isValid(value: NonexistenceProofBody): boolean;
+
+    static toXDR(value: NonexistenceProofBody): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): NonexistenceProofBody;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): NonexistenceProofBody;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ExistenceProofBody {
+    constructor(attributes: {
+      keysToProve: LedgerKey[];
+      lowBoundEntries: ColdArchiveBucketEntry[];
+      highBoundEntries: ColdArchiveBucketEntry[];
+      proofLevels: ArchivalProofNode[][];
+    });
+
+    keysToProve(value?: LedgerKey[]): LedgerKey[];
+
+    lowBoundEntries(value?: ColdArchiveBucketEntry[]): ColdArchiveBucketEntry[];
+
+    highBoundEntries(
+      value?: ColdArchiveBucketEntry[],
+    ): ColdArchiveBucketEntry[];
+
+    proofLevels(value?: ArchivalProofNode[][]): ArchivalProofNode[][];
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ExistenceProofBody;
+
+    static write(value: ExistenceProofBody, io: Buffer): void;
+
+    static isValid(value: ExistenceProofBody): boolean;
+
+    static toXDR(value: ExistenceProofBody): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ExistenceProofBody;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ExistenceProofBody;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ArchivalProof {
+    constructor(attributes: { epoch: number; body: ArchivalProofBody });
+
+    epoch(value?: number): number;
+
+    body(value?: ArchivalProofBody): ArchivalProofBody;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): LedgerFootprint;
+    static read(io: Buffer): ArchivalProof;
 
-    static write(value: LedgerFootprint, io: Buffer): void;
+    static write(value: ArchivalProof, io: Buffer): void;
 
-    static isValid(value: LedgerFootprint): boolean;
+    static isValid(value: ArchivalProof): boolean;
 
-    static toXDR(value: LedgerFootprint): Buffer;
+    static toXDR(value: ArchivalProof): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): LedgerFootprint;
+    static fromXDR(input: Buffer, format?: 'raw'): ArchivalProof;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerFootprint;
+    static fromXDR(input: string, format: 'hex' | 'base64'): ArchivalProof;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
@@ -7294,12 +8335,12 @@ export namespace xdr {
 
   class SorobanTransactionData {
     constructor(attributes: {
-      ext: ExtensionPoint;
+      ext: SorobanTransactionDataExt;
       resources: SorobanResources;
       resourceFee: Int64;
     });
 
-    ext(value?: ExtensionPoint): ExtensionPoint;
+    ext(value?: SorobanTransactionDataExt): SorobanTransactionDataExt;
 
     resources(value?: SorobanResources): SorobanResources;
 
@@ -8135,6 +9176,87 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class ShortHashSeed {
+    constructor(attributes: { seed: Buffer });
+
+    seed(value?: Buffer): Buffer;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ShortHashSeed;
+
+    static write(value: ShortHashSeed, io: Buffer): void;
+
+    static isValid(value: ShortHashSeed): boolean;
+
+    static toXDR(value: ShortHashSeed): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ShortHashSeed;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ShortHashSeed;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class SerializedBinaryFuseFilter {
+    constructor(attributes: {
+      type: BinaryFuseFilterType;
+      inputHashSeed: ShortHashSeed;
+      filterSeed: ShortHashSeed;
+      segmentLength: number;
+      segementLengthMask: number;
+      segmentCount: number;
+      segmentCountLength: number;
+      fingerprintLength: number;
+      fingerprints: Buffer;
+    });
+
+    type(value?: BinaryFuseFilterType): BinaryFuseFilterType;
+
+    inputHashSeed(value?: ShortHashSeed): ShortHashSeed;
+
+    filterSeed(value?: ShortHashSeed): ShortHashSeed;
+
+    segmentLength(value?: number): number;
+
+    segementLengthMask(value?: number): number;
+
+    segmentCount(value?: number): number;
+
+    segmentCountLength(value?: number): number;
+
+    fingerprintLength(value?: number): number;
+
+    fingerprints(value?: Buffer): Buffer;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SerializedBinaryFuseFilter;
+
+    static write(value: SerializedBinaryFuseFilter, io: Buffer): void;
+
+    static isValid(value: SerializedBinaryFuseFilter): boolean;
+
+    static toXDR(value: SerializedBinaryFuseFilter): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): SerializedBinaryFuseFilter;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SerializedBinaryFuseFilter;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class UInt128Parts {
     constructor(attributes: { hi: Uint64; lo: Uint64 });
 
@@ -8350,6 +9472,40 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class ScEnvMetaEntryInterfaceVersion {
+    constructor(attributes: { protocol: number; preRelease: number });
+
+    protocol(value?: number): number;
+
+    preRelease(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ScEnvMetaEntryInterfaceVersion;
+
+    static write(value: ScEnvMetaEntryInterfaceVersion, io: Buffer): void;
+
+    static isValid(value: ScEnvMetaEntryInterfaceVersion): boolean;
+
+    static toXDR(value: ScEnvMetaEntryInterfaceVersion): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): ScEnvMetaEntryInterfaceVersion;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ScEnvMetaEntryInterfaceVersion;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class ScMetaV0 {
     constructor(attributes: { key: string | Buffer; val: string | Buffer });
 
@@ -9052,6 +10208,41 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class ConfigSettingContractParallelComputeV0 {
+    constructor(attributes: { ledgerMaxParallelThreads: number });
+
+    ledgerMaxParallelThreads(value?: number): number;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ConfigSettingContractParallelComputeV0;
+
+    static write(
+      value: ConfigSettingContractParallelComputeV0,
+      io: Buffer,
+    ): void;
+
+    static isValid(value: ConfigSettingContractParallelComputeV0): boolean;
+
+    static toXDR(value: ConfigSettingContractParallelComputeV0): Buffer;
+
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): ConfigSettingContractParallelComputeV0;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ConfigSettingContractParallelComputeV0;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class ConfigSettingContractLedgerCostV0 {
     constructor(attributes: {
       ledgerMaxReadLedgerEntries: number;
@@ -10118,143 +11309,318 @@ export namespace xdr {
 
     static ttl(value: TtlEntry): LedgerEntryData;
 
-    value():
-      | AccountEntry
-      | TrustLineEntry
-      | OfferEntry
-      | DataEntry
-      | ClaimableBalanceEntry
-      | LiquidityPoolEntry
-      | ContractDataEntry
-      | ContractCodeEntry
-      | ConfigSettingEntry
-      | TtlEntry;
+    value():
+      | AccountEntry
+      | TrustLineEntry
+      | OfferEntry
+      | DataEntry
+      | ClaimableBalanceEntry
+      | LiquidityPoolEntry
+      | ContractDataEntry
+      | ContractCodeEntry
+      | ConfigSettingEntry
+      | TtlEntry;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): LedgerEntryData;
+
+    static write(value: LedgerEntryData, io: Buffer): void;
+
+    static isValid(value: LedgerEntryData): boolean;
+
+    static toXDR(value: LedgerEntryData): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): LedgerEntryData;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerEntryData;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class LedgerEntryExt {
+    switch(): number;
+
+    v1(value?: LedgerEntryExtensionV1): LedgerEntryExtensionV1;
+
+    static 0(): LedgerEntryExt;
+
+    static 1(value: LedgerEntryExtensionV1): LedgerEntryExt;
+
+    value(): LedgerEntryExtensionV1 | void;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): LedgerEntryExt;
+
+    static write(value: LedgerEntryExt, io: Buffer): void;
+
+    static isValid(value: LedgerEntryExt): boolean;
+
+    static toXDR(value: LedgerEntryExt): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): LedgerEntryExt;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerEntryExt;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class LedgerKey {
+    switch(): LedgerEntryType;
+
+    account(value?: LedgerKeyAccount): LedgerKeyAccount;
+
+    trustLine(value?: LedgerKeyTrustLine): LedgerKeyTrustLine;
+
+    offer(value?: LedgerKeyOffer): LedgerKeyOffer;
+
+    data(value?: LedgerKeyData): LedgerKeyData;
+
+    claimableBalance(
+      value?: LedgerKeyClaimableBalance,
+    ): LedgerKeyClaimableBalance;
+
+    liquidityPool(value?: LedgerKeyLiquidityPool): LedgerKeyLiquidityPool;
+
+    contractData(value?: LedgerKeyContractData): LedgerKeyContractData;
+
+    contractCode(value?: LedgerKeyContractCode): LedgerKeyContractCode;
+
+    configSetting(value?: LedgerKeyConfigSetting): LedgerKeyConfigSetting;
+
+    ttl(value?: LedgerKeyTtl): LedgerKeyTtl;
+
+    static account(value: LedgerKeyAccount): LedgerKey;
+
+    static trustline(value: LedgerKeyTrustLine): LedgerKey;
+
+    static offer(value: LedgerKeyOffer): LedgerKey;
+
+    static data(value: LedgerKeyData): LedgerKey;
+
+    static claimableBalance(value: LedgerKeyClaimableBalance): LedgerKey;
+
+    static liquidityPool(value: LedgerKeyLiquidityPool): LedgerKey;
+
+    static contractData(value: LedgerKeyContractData): LedgerKey;
+
+    static contractCode(value: LedgerKeyContractCode): LedgerKey;
+
+    static configSetting(value: LedgerKeyConfigSetting): LedgerKey;
+
+    static ttl(value: LedgerKeyTtl): LedgerKey;
+
+    value():
+      | LedgerKeyAccount
+      | LedgerKeyTrustLine
+      | LedgerKeyOffer
+      | LedgerKeyData
+      | LedgerKeyClaimableBalance
+      | LedgerKeyLiquidityPool
+      | LedgerKeyContractData
+      | LedgerKeyContractCode
+      | LedgerKeyConfigSetting
+      | LedgerKeyTtl;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): LedgerKey;
+
+    static write(value: LedgerKey, io: Buffer): void;
+
+    static isValid(value: LedgerKey): boolean;
+
+    static toXDR(value: LedgerKey): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): LedgerKey;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerKey;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class BucketMetadataExt {
+    switch(): number;
+
+    bucketListType(value?: BucketListType): BucketListType;
+
+    static 0(): BucketMetadataExt;
+
+    static 1(value: BucketListType): BucketMetadataExt;
+
+    value(): BucketListType | void;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): LedgerEntryData;
+    static read(io: Buffer): BucketMetadataExt;
 
-    static write(value: LedgerEntryData, io: Buffer): void;
+    static write(value: BucketMetadataExt, io: Buffer): void;
 
-    static isValid(value: LedgerEntryData): boolean;
+    static isValid(value: BucketMetadataExt): boolean;
 
-    static toXDR(value: LedgerEntryData): Buffer;
+    static toXDR(value: BucketMetadataExt): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): LedgerEntryData;
+    static fromXDR(input: Buffer, format?: 'raw'): BucketMetadataExt;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerEntryData;
+    static fromXDR(input: string, format: 'hex' | 'base64'): BucketMetadataExt;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class LedgerEntryExt {
-    switch(): number;
+  class BucketEntry {
+    switch(): BucketEntryType;
 
-    v1(value?: LedgerEntryExtensionV1): LedgerEntryExtensionV1;
+    liveEntry(value?: LedgerEntry): LedgerEntry;
 
-    static 0(): LedgerEntryExt;
+    deadEntry(value?: LedgerKey): LedgerKey;
 
-    static 1(value: LedgerEntryExtensionV1): LedgerEntryExt;
+    metaEntry(value?: BucketMetadata): BucketMetadata;
 
-    value(): LedgerEntryExtensionV1 | void;
+    static liveentry(value: LedgerEntry): BucketEntry;
+
+    static initentry(value: LedgerEntry): BucketEntry;
+
+    static deadentry(value: LedgerKey): BucketEntry;
+
+    static metaentry(value: BucketMetadata): BucketEntry;
+
+    value(): LedgerEntry | LedgerKey | BucketMetadata;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): LedgerEntryExt;
+    static read(io: Buffer): BucketEntry;
 
-    static write(value: LedgerEntryExt, io: Buffer): void;
+    static write(value: BucketEntry, io: Buffer): void;
 
-    static isValid(value: LedgerEntryExt): boolean;
+    static isValid(value: BucketEntry): boolean;
 
-    static toXDR(value: LedgerEntryExt): Buffer;
+    static toXDR(value: BucketEntry): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): LedgerEntryExt;
+    static fromXDR(input: Buffer, format?: 'raw'): BucketEntry;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerEntryExt;
+    static fromXDR(input: string, format: 'hex' | 'base64'): BucketEntry;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class LedgerKey {
-    switch(): LedgerEntryType;
+  class HotArchiveBucketEntry {
+    switch(): HotArchiveBucketEntryType;
 
-    account(value?: LedgerKeyAccount): LedgerKeyAccount;
+    archivedEntry(value?: LedgerEntry): LedgerEntry;
 
-    trustLine(value?: LedgerKeyTrustLine): LedgerKeyTrustLine;
+    key(value?: LedgerKey): LedgerKey;
 
-    offer(value?: LedgerKeyOffer): LedgerKeyOffer;
+    metaEntry(value?: BucketMetadata): BucketMetadata;
 
-    data(value?: LedgerKeyData): LedgerKeyData;
+    static hotArchiveArchived(value: LedgerEntry): HotArchiveBucketEntry;
 
-    claimableBalance(
-      value?: LedgerKeyClaimableBalance,
-    ): LedgerKeyClaimableBalance;
+    static hotArchiveLive(value: LedgerKey): HotArchiveBucketEntry;
 
-    liquidityPool(value?: LedgerKeyLiquidityPool): LedgerKeyLiquidityPool;
+    static hotArchiveDeleted(value: LedgerKey): HotArchiveBucketEntry;
 
-    contractData(value?: LedgerKeyContractData): LedgerKeyContractData;
+    static hotArchiveMetaentry(value: BucketMetadata): HotArchiveBucketEntry;
 
-    contractCode(value?: LedgerKeyContractCode): LedgerKeyContractCode;
+    value(): LedgerEntry | LedgerKey | BucketMetadata;
 
-    configSetting(value?: LedgerKeyConfigSetting): LedgerKeyConfigSetting;
+    toXDR(format?: 'raw'): Buffer;
 
-    ttl(value?: LedgerKeyTtl): LedgerKeyTtl;
+    toXDR(format: 'hex' | 'base64'): string;
 
-    static account(value: LedgerKeyAccount): LedgerKey;
+    static read(io: Buffer): HotArchiveBucketEntry;
 
-    static trustline(value: LedgerKeyTrustLine): LedgerKey;
+    static write(value: HotArchiveBucketEntry, io: Buffer): void;
 
-    static offer(value: LedgerKeyOffer): LedgerKey;
+    static isValid(value: HotArchiveBucketEntry): boolean;
 
-    static data(value: LedgerKeyData): LedgerKey;
+    static toXDR(value: HotArchiveBucketEntry): Buffer;
 
-    static claimableBalance(value: LedgerKeyClaimableBalance): LedgerKey;
+    static fromXDR(input: Buffer, format?: 'raw'): HotArchiveBucketEntry;
 
-    static liquidityPool(value: LedgerKeyLiquidityPool): LedgerKey;
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): HotArchiveBucketEntry;
 
-    static contractData(value: LedgerKeyContractData): LedgerKey;
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
-    static contractCode(value: LedgerKeyContractCode): LedgerKey;
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
 
-    static configSetting(value: LedgerKeyConfigSetting): LedgerKey;
+  class ColdArchiveBucketEntry {
+    switch(): ColdArchiveBucketEntryType;
 
-    static ttl(value: LedgerKeyTtl): LedgerKey;
+    metaEntry(value?: BucketMetadata): BucketMetadata;
+
+    archivedLeaf(value?: ColdArchiveArchivedLeaf): ColdArchiveArchivedLeaf;
+
+    deletedLeaf(value?: ColdArchiveDeletedLeaf): ColdArchiveDeletedLeaf;
+
+    boundaryLeaf(value?: ColdArchiveBoundaryLeaf): ColdArchiveBoundaryLeaf;
+
+    hashEntry(value?: ColdArchiveHashEntry): ColdArchiveHashEntry;
+
+    static coldArchiveMetaentry(value: BucketMetadata): ColdArchiveBucketEntry;
+
+    static coldArchiveArchivedLeaf(
+      value: ColdArchiveArchivedLeaf,
+    ): ColdArchiveBucketEntry;
+
+    static coldArchiveDeletedLeaf(
+      value: ColdArchiveDeletedLeaf,
+    ): ColdArchiveBucketEntry;
+
+    static coldArchiveBoundaryLeaf(
+      value: ColdArchiveBoundaryLeaf,
+    ): ColdArchiveBucketEntry;
+
+    static coldArchiveHash(value: ColdArchiveHashEntry): ColdArchiveBucketEntry;
 
     value():
-      | LedgerKeyAccount
-      | LedgerKeyTrustLine
-      | LedgerKeyOffer
-      | LedgerKeyData
-      | LedgerKeyClaimableBalance
-      | LedgerKeyLiquidityPool
-      | LedgerKeyContractData
-      | LedgerKeyContractCode
-      | LedgerKeyConfigSetting
-      | LedgerKeyTtl;
+      | BucketMetadata
+      | ColdArchiveArchivedLeaf
+      | ColdArchiveDeletedLeaf
+      | ColdArchiveBoundaryLeaf
+      | ColdArchiveHashEntry;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): LedgerKey;
+    static read(io: Buffer): ColdArchiveBucketEntry;
 
-    static write(value: LedgerKey, io: Buffer): void;
+    static write(value: ColdArchiveBucketEntry, io: Buffer): void;
 
-    static isValid(value: LedgerKey): boolean;
+    static isValid(value: ColdArchiveBucketEntry): boolean;
 
-    static toXDR(value: LedgerKey): Buffer;
+    static toXDR(value: ColdArchiveBucketEntry): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): LedgerKey;
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveBucketEntry;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): LedgerKey;
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveBucketEntry;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
@@ -10421,74 +11787,6 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class BucketMetadataExt {
-    switch(): number;
-
-    static 0(): BucketMetadataExt;
-
-    value(): void;
-
-    toXDR(format?: 'raw'): Buffer;
-
-    toXDR(format: 'hex' | 'base64'): string;
-
-    static read(io: Buffer): BucketMetadataExt;
-
-    static write(value: BucketMetadataExt, io: Buffer): void;
-
-    static isValid(value: BucketMetadataExt): boolean;
-
-    static toXDR(value: BucketMetadataExt): Buffer;
-
-    static fromXDR(input: Buffer, format?: 'raw'): BucketMetadataExt;
-
-    static fromXDR(input: string, format: 'hex' | 'base64'): BucketMetadataExt;
-
-    static validateXDR(input: Buffer, format?: 'raw'): boolean;
-
-    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
-  }
-
-  class BucketEntry {
-    switch(): BucketEntryType;
-
-    liveEntry(value?: LedgerEntry): LedgerEntry;
-
-    deadEntry(value?: LedgerKey): LedgerKey;
-
-    metaEntry(value?: BucketMetadata): BucketMetadata;
-
-    static liveentry(value: LedgerEntry): BucketEntry;
-
-    static initentry(value: LedgerEntry): BucketEntry;
-
-    static deadentry(value: LedgerKey): BucketEntry;
-
-    static metaentry(value: BucketMetadata): BucketEntry;
-
-    value(): LedgerEntry | LedgerKey | BucketMetadata;
-
-    toXDR(format?: 'raw'): Buffer;
-
-    toXDR(format: 'hex' | 'base64'): string;
-
-    static read(io: Buffer): BucketEntry;
-
-    static write(value: BucketEntry, io: Buffer): void;
-
-    static isValid(value: BucketEntry): boolean;
-
-    static toXDR(value: BucketEntry): Buffer;
-
-    static fromXDR(input: Buffer, format?: 'raw'): BucketEntry;
-
-    static fromXDR(input: string, format: 'hex' | 'base64'): BucketEntry;
-
-    static validateXDR(input: Buffer, format?: 'raw'): boolean;
-
-    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
-  }
-
   class TxSetComponent {
     switch(): TxSetComponentType;
 
@@ -10528,9 +11826,13 @@ export namespace xdr {
 
     v0Components(value?: TxSetComponent[]): TxSetComponent[];
 
+    parallelTxsComponent(value?: ParallelTxsComponent): ParallelTxsComponent;
+
     static 0(value: TxSetComponent[]): TransactionPhase;
 
-    value(): TxSetComponent[];
+    static 1(value: ParallelTxsComponent): TransactionPhase;
+
+    value(): TxSetComponent[] | ParallelTxsComponent;
 
     toXDR(format?: 'raw'): Buffer;
 
@@ -10982,6 +12284,10 @@ export namespace xdr {
       value?: TopologyResponseBodyV1,
     ): TopologyResponseBodyV1;
 
+    topologyResponseBodyV2(
+      value?: TopologyResponseBodyV2,
+    ): TopologyResponseBodyV2;
+
     static surveyTopologyResponseV0(
       value: TopologyResponseBodyV0,
     ): SurveyResponseBody;
@@ -10990,7 +12296,14 @@ export namespace xdr {
       value: TopologyResponseBodyV1,
     ): SurveyResponseBody;
 
-    value(): TopologyResponseBodyV0 | TopologyResponseBodyV1;
+    static surveyTopologyResponseV2(
+      value: TopologyResponseBodyV2,
+    ): SurveyResponseBody;
+
+    value():
+      | TopologyResponseBodyV0
+      | TopologyResponseBodyV1
+      | TopologyResponseBodyV2;
 
     toXDR(format?: 'raw'): Buffer;
 
@@ -11044,6 +12357,22 @@ export namespace xdr {
       value?: SignedSurveyResponseMessage,
     ): SignedSurveyResponseMessage;
 
+    signedTimeSlicedSurveyRequestMessage(
+      value?: SignedTimeSlicedSurveyRequestMessage,
+    ): SignedTimeSlicedSurveyRequestMessage;
+
+    signedTimeSlicedSurveyResponseMessage(
+      value?: SignedTimeSlicedSurveyResponseMessage,
+    ): SignedTimeSlicedSurveyResponseMessage;
+
+    signedTimeSlicedSurveyStartCollectingMessage(
+      value?: SignedTimeSlicedSurveyStartCollectingMessage,
+    ): SignedTimeSlicedSurveyStartCollectingMessage;
+
+    signedTimeSlicedSurveyStopCollectingMessage(
+      value?: SignedTimeSlicedSurveyStopCollectingMessage,
+    ): SignedTimeSlicedSurveyStopCollectingMessage;
+
     qSetHash(value?: Buffer): Buffer;
 
     qSet(value?: ScpQuorumSet): ScpQuorumSet;
@@ -11084,6 +12413,22 @@ export namespace xdr {
 
     static surveyResponse(value: SignedSurveyResponseMessage): StellarMessage;
 
+    static timeSlicedSurveyRequest(
+      value: SignedTimeSlicedSurveyRequestMessage,
+    ): StellarMessage;
+
+    static timeSlicedSurveyResponse(
+      value: SignedTimeSlicedSurveyResponseMessage,
+    ): StellarMessage;
+
+    static timeSlicedSurveyStartCollecting(
+      value: SignedTimeSlicedSurveyStartCollectingMessage,
+    ): StellarMessage;
+
+    static timeSlicedSurveyStopCollecting(
+      value: SignedTimeSlicedSurveyStopCollectingMessage,
+    ): StellarMessage;
+
     static getScpQuorumset(value: Buffer): StellarMessage;
 
     static scpQuorumset(value: ScpQuorumSet): StellarMessage;
@@ -11112,6 +12457,10 @@ export namespace xdr {
       | TransactionEnvelope
       | SignedSurveyRequestMessage
       | SignedSurveyResponseMessage
+      | SignedTimeSlicedSurveyRequestMessage
+      | SignedTimeSlicedSurveyResponseMessage
+      | SignedTimeSlicedSurveyStartCollectingMessage
+      | SignedTimeSlicedSurveyStopCollectingMessage
       | Buffer
       | ScpQuorumSet
       | ScpEnvelope
@@ -11373,6 +12722,8 @@ export namespace xdr {
 
     wasm(value?: Buffer): Buffer;
 
+    createContractV2(value?: CreateContractArgsV2): CreateContractArgsV2;
+
     static hostFunctionTypeInvokeContract(
       value: InvokeContractArgs,
     ): HostFunction;
@@ -11383,7 +12734,15 @@ export namespace xdr {
 
     static hostFunctionTypeUploadContractWasm(value: Buffer): HostFunction;
 
-    value(): InvokeContractArgs | CreateContractArgs | Buffer;
+    static hostFunctionTypeCreateContractV2(
+      value: CreateContractArgsV2,
+    ): HostFunction;
+
+    value():
+      | InvokeContractArgs
+      | CreateContractArgs
+      | Buffer
+      | CreateContractArgsV2;
 
     toXDR(format?: 'raw'): Buffer;
 
@@ -11413,6 +12772,8 @@ export namespace xdr {
 
     createContractHostFn(value?: CreateContractArgs): CreateContractArgs;
 
+    createContractV2HostFn(value?: CreateContractArgsV2): CreateContractArgsV2;
+
     static sorobanAuthorizedFunctionTypeContractFn(
       value: InvokeContractArgs,
     ): SorobanAuthorizedFunction;
@@ -11421,7 +12782,11 @@ export namespace xdr {
       value: CreateContractArgs,
     ): SorobanAuthorizedFunction;
 
-    value(): InvokeContractArgs | CreateContractArgs;
+    static sorobanAuthorizedFunctionTypeCreateContractV2HostFn(
+      value: CreateContractArgsV2,
+    ): SorobanAuthorizedFunction;
+
+    value(): InvokeContractArgs | CreateContractArgs | CreateContractArgsV2;
 
     toXDR(format?: 'raw'): Buffer;
 
@@ -11799,6 +13164,75 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
+  class ArchivalProofBody {
+    switch(): ArchivalProofType;
+
+    nonexistenceProof(value?: NonexistenceProofBody): NonexistenceProofBody;
+
+    existenceProof(value?: ExistenceProofBody): ExistenceProofBody;
+
+    static existence(value: NonexistenceProofBody): ArchivalProofBody;
+
+    static nonexistence(value: ExistenceProofBody): ArchivalProofBody;
+
+    value(): NonexistenceProofBody | ExistenceProofBody;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ArchivalProofBody;
+
+    static write(value: ArchivalProofBody, io: Buffer): void;
+
+    static isValid(value: ArchivalProofBody): boolean;
+
+    static toXDR(value: ArchivalProofBody): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ArchivalProofBody;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ArchivalProofBody;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class SorobanTransactionDataExt {
+    switch(): number;
+
+    proofs(value?: ArchivalProof[]): ArchivalProof[];
+
+    static 0(): SorobanTransactionDataExt;
+
+    static 1(value: ArchivalProof[]): SorobanTransactionDataExt;
+
+    value(): ArchivalProof[] | void;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): SorobanTransactionDataExt;
+
+    static write(value: SorobanTransactionDataExt, io: Buffer): void;
+
+    static isValid(value: SorobanTransactionDataExt): boolean;
+
+    static toXDR(value: SorobanTransactionDataExt): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): SorobanTransactionDataExt;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): SorobanTransactionDataExt;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class TransactionV0Ext {
     switch(): number;
 
@@ -14050,11 +15484,15 @@ export namespace xdr {
   class ScEnvMetaEntry {
     switch(): ScEnvMetaKind;
 
-    interfaceVersion(value?: Uint64): Uint64;
+    interfaceVersion(
+      value?: ScEnvMetaEntryInterfaceVersion,
+    ): ScEnvMetaEntryInterfaceVersion;
 
-    static scEnvMetaKindInterfaceVersion(value: Uint64): ScEnvMetaEntry;
+    static scEnvMetaKindInterfaceVersion(
+      value: ScEnvMetaEntryInterfaceVersion,
+    ): ScEnvMetaEntry;
 
-    value(): Uint64;
+    value(): ScEnvMetaEntryInterfaceVersion;
 
     toXDR(format?: 'raw'): Buffer;
 
@@ -14344,6 +15782,10 @@ export namespace xdr {
 
     evictionIterator(value?: EvictionIterator): EvictionIterator;
 
+    contractParallelCompute(
+      value?: ConfigSettingContractParallelComputeV0,
+    ): ConfigSettingContractParallelComputeV0;
+
     static configSettingContractMaxSizeBytes(value: number): ConfigSettingEntry;
 
     static configSettingContractComputeV0(
@@ -14398,6 +15840,10 @@ export namespace xdr {
       value: EvictionIterator,
     ): ConfigSettingEntry;
 
+    static configSettingContractParallelComputeV0(
+      value: ConfigSettingContractParallelComputeV0,
+    ): ConfigSettingEntry;
+
     value():
       | number
       | ConfigSettingContractComputeV0
@@ -14412,7 +15858,8 @@ export namespace xdr {
       | StateArchivalSettings
       | ConfigSettingContractExecutionLanesV0
       | Uint64[]
-      | EvictionIterator;
+      | EvictionIterator
+      | ConfigSettingContractParallelComputeV0;
 
     toXDR(format?: 'raw'): Buffer;