@stellar/stellar-base 12.1.1 → 13.0.0

package/types/curr.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 {};
@@ -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 {
@@ -2450,14 +2656,20 @@ export namespace xdr {
 
   const LedgerEntryChanges: XDRArray<LedgerEntryChange>;
 
+  const DiagnosticEvents: XDRArray<DiagnosticEvent>;
+
   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 +4280,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,60 +4660,32 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class BucketMetadata {
-    constructor(attributes: { ledgerVersion: number; ext: BucketMetadataExt });
+  class TxSetComponentTxsMaybeDiscountedFee {
+    constructor(attributes: {
+      baseFee: null | Int64;
+      txes: TransactionEnvelope[];
+    });
 
-    ledgerVersion(value?: number): number;
+    baseFee(value?: null | Int64): null | Int64;
 
-    ext(value?: BucketMetadataExt): BucketMetadataExt;
+    txes(value?: TransactionEnvelope[]): TransactionEnvelope[];
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): BucketMetadata;
-
-    static write(value: BucketMetadata, io: Buffer): void;
+    static read(io: Buffer): TxSetComponentTxsMaybeDiscountedFee;
 
-    static isValid(value: BucketMetadata): boolean;
+    static write(value: TxSetComponentTxsMaybeDiscountedFee, io: Buffer): void;
 
-    static toXDR(value: BucketMetadata): Buffer;
+    static isValid(value: TxSetComponentTxsMaybeDiscountedFee): boolean;
 
-    static fromXDR(input: Buffer, format?: 'raw'): BucketMetadata;
+    static toXDR(value: TxSetComponentTxsMaybeDiscountedFee): Buffer;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): BucketMetadata;
-
-    static validateXDR(input: Buffer, format?: 'raw'): boolean;
-
-    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
-  }
-
-  class TxSetComponentTxsMaybeDiscountedFee {
-    constructor(attributes: {
-      baseFee: null | Int64;
-      txes: TransactionEnvelope[];
-    });
-
-    baseFee(value?: null | Int64): null | Int64;
-
-    txes(value?: TransactionEnvelope[]): TransactionEnvelope[];
-
-    toXDR(format?: 'raw'): Buffer;
-
-    toXDR(format: 'hex' | 'base64'): string;
-
-    static read(io: Buffer): TxSetComponentTxsMaybeDiscountedFee;
-
-    static write(value: TxSetComponentTxsMaybeDiscountedFee, io: Buffer): void;
-
-    static isValid(value: TxSetComponentTxsMaybeDiscountedFee): boolean;
-
-    static toXDR(value: TxSetComponentTxsMaybeDiscountedFee): Buffer;
-
-    static fromXDR(
-      input: Buffer,
-      format?: 'raw',
-    ): TxSetComponentTxsMaybeDiscountedFee;
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): TxSetComponentTxsMaybeDiscountedFee;
 
     static fromXDR(
       input: string,
@@ -5449,6 +5787,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 +6002,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 +6079,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 +6161,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;
@@ -5600,73 +6226,198 @@ export namespace xdr {
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
-    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
-  }
+    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;
+      versionStr: string | Buffer;
+      messagesRead: Uint64;
+      messagesWritten: Uint64;
+      bytesRead: Uint64;
+      bytesWritten: Uint64;
+      secondsConnected: Uint64;
+      uniqueFloodBytesRecv: Uint64;
+      duplicateFloodBytesRecv: Uint64;
+      uniqueFetchBytesRecv: Uint64;
+      duplicateFetchBytesRecv: Uint64;
+      uniqueFloodMessageRecv: Uint64;
+      duplicateFloodMessageRecv: Uint64;
+      uniqueFetchMessageRecv: Uint64;
+      duplicateFetchMessageRecv: Uint64;
+    });
+
+    id(value?: NodeId): NodeId;
+
+    versionStr(value?: string | Buffer): string | Buffer;
+
+    messagesRead(value?: Uint64): Uint64;
+
+    messagesWritten(value?: Uint64): Uint64;
+
+    bytesRead(value?: Uint64): Uint64;
+
+    bytesWritten(value?: Uint64): Uint64;
+
+    secondsConnected(value?: Uint64): Uint64;
+
+    uniqueFloodBytesRecv(value?: Uint64): Uint64;
+
+    duplicateFloodBytesRecv(value?: Uint64): Uint64;
+
+    uniqueFetchBytesRecv(value?: Uint64): Uint64;
+
+    duplicateFetchBytesRecv(value?: Uint64): Uint64;
+
+    uniqueFloodMessageRecv(value?: Uint64): Uint64;
+
+    duplicateFloodMessageRecv(value?: Uint64): Uint64;
+
+    uniqueFetchMessageRecv(value?: Uint64): Uint64;
+
+    duplicateFetchMessageRecv(value?: Uint64): Uint64;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): PeerStats;
+
+    static write(value: PeerStats, io: Buffer): void;
+
+    static isValid(value: PeerStats): boolean;
+
+    static toXDR(value: PeerStats): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): PeerStats;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): PeerStats;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    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;
 
-  class PeerStats {
-    constructor(attributes: {
-      id: NodeId;
-      versionStr: string | Buffer;
-      messagesRead: Uint64;
-      messagesWritten: Uint64;
-      bytesRead: Uint64;
-      bytesWritten: Uint64;
-      secondsConnected: Uint64;
-      uniqueFloodBytesRecv: Uint64;
-      duplicateFloodBytesRecv: Uint64;
-      uniqueFetchBytesRecv: Uint64;
-      duplicateFetchBytesRecv: Uint64;
-      uniqueFloodMessageRecv: Uint64;
-      duplicateFloodMessageRecv: Uint64;
-      uniqueFetchMessageRecv: Uint64;
-      duplicateFetchMessageRecv: Uint64;
-    });
+    isValidator(value?: boolean): boolean;
 
-    id(value?: NodeId): NodeId;
+    maxInboundPeerCount(value?: number): number;
 
-    versionStr(value?: string | Buffer): string | Buffer;
+    maxOutboundPeerCount(value?: number): number;
 
-    messagesRead(value?: Uint64): Uint64;
+    toXDR(format?: 'raw'): Buffer;
 
-    messagesWritten(value?: Uint64): Uint64;
+    toXDR(format: 'hex' | 'base64'): string;
 
-    bytesRead(value?: Uint64): Uint64;
+    static read(io: Buffer): TimeSlicedNodeData;
 
-    bytesWritten(value?: Uint64): Uint64;
+    static write(value: TimeSlicedNodeData, io: Buffer): void;
 
-    secondsConnected(value?: Uint64): Uint64;
+    static isValid(value: TimeSlicedNodeData): boolean;
 
-    uniqueFloodBytesRecv(value?: Uint64): Uint64;
+    static toXDR(value: TimeSlicedNodeData): Buffer;
 
-    duplicateFloodBytesRecv(value?: Uint64): Uint64;
+    static fromXDR(input: Buffer, format?: 'raw'): TimeSlicedNodeData;
 
-    uniqueFetchBytesRecv(value?: Uint64): Uint64;
+    static fromXDR(input: string, format: 'hex' | 'base64'): TimeSlicedNodeData;
 
-    duplicateFetchBytesRecv(value?: Uint64): Uint64;
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
-    uniqueFloodMessageRecv(value?: Uint64): Uint64;
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
 
-    duplicateFloodMessageRecv(value?: Uint64): Uint64;
+  class TimeSlicedPeerData {
+    constructor(attributes: { peerStats: PeerStats; averageLatencyMs: number });
 
-    uniqueFetchMessageRecv(value?: Uint64): Uint64;
+    peerStats(value?: PeerStats): PeerStats;
 
-    duplicateFetchMessageRecv(value?: Uint64): Uint64;
+    averageLatencyMs(value?: number): number;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): PeerStats;
+    static read(io: Buffer): TimeSlicedPeerData;
 
-    static write(value: PeerStats, io: Buffer): void;
+    static write(value: TimeSlicedPeerData, io: Buffer): void;
 
-    static isValid(value: PeerStats): boolean;
+    static isValid(value: TimeSlicedPeerData): boolean;
 
-    static toXDR(value: PeerStats): Buffer;
+    static toXDR(value: TimeSlicedPeerData): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): PeerStats;
+    static fromXDR(input: Buffer, format?: 'raw'): TimeSlicedPeerData;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): PeerStats;
+    static fromXDR(input: string, format: 'hex' | 'base64'): TimeSlicedPeerData;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
@@ -5759,6 +6510,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 +7520,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;
@@ -7255,6 +8080,135 @@ export namespace xdr {
     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): ArchivalProof;
+
+    static write(value: ArchivalProof, io: Buffer): void;
+
+    static isValid(value: ArchivalProof): boolean;
+
+    static toXDR(value: ArchivalProof): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ArchivalProof;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ArchivalProof;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class SorobanResources {
     constructor(attributes: {
       footprint: LedgerFootprint;
@@ -8135,6 +9089,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 });
 
@@ -8322,28 +9357,62 @@ export namespace xdr {
     static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
   }
 
-  class ScMapEntry {
-    constructor(attributes: { key: ScVal; val: ScVal });
+  class ScMapEntry {
+    constructor(attributes: { key: ScVal; val: ScVal });
+
+    key(value?: ScVal): ScVal;
+
+    val(value?: ScVal): ScVal;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ScMapEntry;
+
+    static write(value: ScMapEntry, io: Buffer): void;
+
+    static isValid(value: ScMapEntry): boolean;
+
+    static toXDR(value: ScMapEntry): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ScMapEntry;
+
+    static fromXDR(input: string, format: 'hex' | 'base64'): ScMapEntry;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ScEnvMetaEntryInterfaceVersion {
+    constructor(attributes: { protocol: number; preRelease: number });
 
-    key(value?: ScVal): ScVal;
+    protocol(value?: number): number;
 
-    val(value?: ScVal): ScVal;
+    preRelease(value?: number): number;
 
     toXDR(format?: 'raw'): Buffer;
 
     toXDR(format: 'hex' | 'base64'): string;
 
-    static read(io: Buffer): ScMapEntry;
+    static read(io: Buffer): ScEnvMetaEntryInterfaceVersion;
 
-    static write(value: ScMapEntry, io: Buffer): void;
+    static write(value: ScEnvMetaEntryInterfaceVersion, io: Buffer): void;
 
-    static isValid(value: ScMapEntry): boolean;
+    static isValid(value: ScEnvMetaEntryInterfaceVersion): boolean;
 
-    static toXDR(value: ScMapEntry): Buffer;
+    static toXDR(value: ScEnvMetaEntryInterfaceVersion): Buffer;
 
-    static fromXDR(input: Buffer, format?: 'raw'): ScMapEntry;
+    static fromXDR(
+      input: Buffer,
+      format?: 'raw',
+    ): ScEnvMetaEntryInterfaceVersion;
 
-    static fromXDR(input: string, format: 'hex' | 'base64'): ScMapEntry;
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ScEnvMetaEntryInterfaceVersion;
 
     static validateXDR(input: Buffer, format?: 'raw'): boolean;
 
@@ -10261,6 +11330,181 @@ export namespace xdr {
     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): 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 HotArchiveBucketEntry {
+    switch(): HotArchiveBucketEntryType;
+
+    archivedEntry(value?: LedgerEntry): LedgerEntry;
+
+    key(value?: LedgerKey): LedgerKey;
+
+    metaEntry(value?: BucketMetadata): BucketMetadata;
+
+    static hotArchiveArchived(value: LedgerEntry): HotArchiveBucketEntry;
+
+    static hotArchiveLive(value: LedgerKey): HotArchiveBucketEntry;
+
+    static hotArchiveDeleted(value: LedgerKey): HotArchiveBucketEntry;
+
+    static hotArchiveMetaentry(value: BucketMetadata): HotArchiveBucketEntry;
+
+    value(): LedgerEntry | LedgerKey | BucketMetadata;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): HotArchiveBucketEntry;
+
+    static write(value: HotArchiveBucketEntry, io: Buffer): void;
+
+    static isValid(value: HotArchiveBucketEntry): boolean;
+
+    static toXDR(value: HotArchiveBucketEntry): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): HotArchiveBucketEntry;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): HotArchiveBucketEntry;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
+  class ColdArchiveBucketEntry {
+    switch(): ColdArchiveBucketEntryType;
+
+    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():
+      | BucketMetadata
+      | ColdArchiveArchivedLeaf
+      | ColdArchiveDeletedLeaf
+      | ColdArchiveBoundaryLeaf
+      | ColdArchiveHashEntry;
+
+    toXDR(format?: 'raw'): Buffer;
+
+    toXDR(format: 'hex' | 'base64'): string;
+
+    static read(io: Buffer): ColdArchiveBucketEntry;
+
+    static write(value: ColdArchiveBucketEntry, io: Buffer): void;
+
+    static isValid(value: ColdArchiveBucketEntry): boolean;
+
+    static toXDR(value: ColdArchiveBucketEntry): Buffer;
+
+    static fromXDR(input: Buffer, format?: 'raw'): ColdArchiveBucketEntry;
+
+    static fromXDR(
+      input: string,
+      format: 'hex' | 'base64',
+    ): ColdArchiveBucketEntry;
+
+    static validateXDR(input: Buffer, format?: 'raw'): boolean;
+
+    static validateXDR(input: string, format: 'hex' | 'base64'): boolean;
+  }
+
   class StellarValueExt {
     switch(): StellarValueType;
 
@@ -10421,74 +11665,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;
 
@@ -10982,6 +12158,10 @@ export namespace xdr {
       value?: TopologyResponseBodyV1,
     ): TopologyResponseBodyV1;
 
+    topologyResponseBodyV2(
+      value?: TopologyResponseBodyV2,
+    ): TopologyResponseBodyV2;
+
     static surveyTopologyResponseV0(
       value: TopologyResponseBodyV0,
     ): SurveyResponseBody;
@@ -10990,7 +12170,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 +12231,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 +12287,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 +12331,10 @@ export namespace xdr {
       | TransactionEnvelope
       | SignedSurveyRequestMessage
       | SignedSurveyResponseMessage
+      | SignedTimeSlicedSurveyRequestMessage
+      | SignedTimeSlicedSurveyResponseMessage
+      | SignedTimeSlicedSurveyStartCollectingMessage
+      | SignedTimeSlicedSurveyStopCollectingMessage
       | Buffer
       | ScpQuorumSet
       | ScpEnvelope
@@ -11373,6 +12596,8 @@ export namespace xdr {
 
     wasm(value?: Buffer): Buffer;
 
+    createContractV2(value?: CreateContractArgsV2): CreateContractArgsV2;
+
     static hostFunctionTypeInvokeContract(
       value: InvokeContractArgs,
     ): HostFunction;
@@ -11383,7 +12608,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 +12646,8 @@ export namespace xdr {
 
     createContractHostFn(value?: CreateContractArgs): CreateContractArgs;
 
+    createContractV2HostFn(value?: CreateContractArgsV2): CreateContractArgsV2;
+
     static sorobanAuthorizedFunctionTypeContractFn(
       value: InvokeContractArgs,
     ): SorobanAuthorizedFunction;
@@ -11421,7 +12656,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 +13038,40 @@ 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 TransactionV0Ext {
     switch(): number;
 
@@ -14050,11 +15323,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;