Class WalrusClient

constructor

• new WalrusClient(config: WalrusClientConfig): WalrusClient

  Parameters

  • config: WalrusClientConfig

  Returns WalrusClient

readBlob

certifyBlob

• certifyBlob(
      __namedParameters: CertifyBlobOptions,
  ): Promise<(tx: Transaction) => void>

  Certify a blob in a transaction

  Parameters

  • __namedParameters: CertifyBlobOptions

  Returns Promise<(tx: Transaction) => void>

  Usage

  tx.add(await client.certifyBlob({ blobId, blobObjectId, confirmations }));
  Copy

certifyBlobTransaction

• certifyBlobTransaction(
      __namedParameters: CertifyBlobOptions & { transaction?: Transaction },
  ): Promise<Transaction>

  Create a transaction that certifies a blob

  Parameters

  • __namedParameters: CertifyBlobOptions & { transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.certifyBlobTransaction({ blobId, blobObjectId, confirmations });
  Copy

createStorage

• createStorage(
      __namedParameters: StorageWithSizeOptions,
  ): Promise<(tx: Transaction) => TransactionResult>

  A utility for creating a storage object in a transaction.

  Parameters

  • __namedParameters: StorageWithSizeOptions

  Returns Promise<(tx: Transaction) => TransactionResult>

  Usage

  tx.transferObjects([await client.createStorage({ size: 1000, epochs: 3 })], owner);
  Copy

createStorageTransaction

• createStorageTransaction(
      __namedParameters: StorageWithSizeOptions & {
          transaction?: Transaction;
      },
  ): Promise<Transaction>

  Create a transaction that creates a storage object

  Parameters

  • __namedParameters: StorageWithSizeOptions & { transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.createStorageTransaction({ size: 1000, epochs: 3, owner: signer.toSuiAddress() });
  Copy

deleteBlob

• deleteBlob(
      __namedParameters: DeleteBlobOptions,
  ): Promise<(tx: Transaction) => TransactionResult>

  Delete a blob in a transaction

  Parameters

  • __namedParameters: DeleteBlobOptions

  Returns Promise<(tx: Transaction) => TransactionResult>

  Usage

  const storage = await client.deleteBlob({ blobObjectId });
  tx.transferObjects([storage], owner);
  Copy

deleteBlobTransaction

• deleteBlobTransaction(
      __namedParameters: DeleteBlobOptions & {
          owner: string;
          transaction?: Transaction;
      },
  ): Promise<Transaction>

  Create a transaction that deletes a blob

  Parameters

  • __namedParameters: DeleteBlobOptions & { owner: string; transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.deleteBlobTransaction({ blobObjectId, owner });
  Copy

encodeBlob

• encodeBlob(
      blob: Uint8Array,
  ): Promise<
      {
          blobId: string;
          metadata: {
              V1: {
                  encoding_type: | "RedStuff"
                  | "RS2"
                  | { RedStuff: null
                  | boolean
                  | object }
                  | { RS2: null | boolean | object };
                  hashes: Iterable<
                      {
                          primary_hash: EnumInputShape<
                              {
                                  Digest: Iterable<number, any, any>;
                                  Empty: null | boolean | object;
                              },
                          >;
                          secondary_hash: EnumInputShape<
                              {
                                  Digest: Iterable<number, any, any>;
                                  Empty: null | boolean | object;
                              },
                          >;
                      },
                      any,
                      any,
                  > & { length: number };
                  unencoded_length: string | number | bigint;
              };
          };
          rootHash: Uint8Array<ArrayBufferLike>;
          sliversByNode: SliversForNode[];
      },
  >

  Encode a blob into slivers for each node

  Parameters

  • blob: Uint8Array

  Returns Promise<
      {
          blobId: string;
          metadata: {
              V1: {
                  encoding_type: | "RedStuff"
                  | "RS2"
                  | { RedStuff: null
                  | boolean
                  | object }
                  | { RS2: null | boolean | object };
                  hashes: Iterable<
                      {
                          primary_hash: EnumInputShape<
                              {
                                  Digest: Iterable<number, any, any>;
                                  Empty: null | boolean | object;
                              },
                          >;
                          secondary_hash: EnumInputShape<
                              {
                                  Digest: Iterable<number, any, any>;
                                  Empty: null | boolean | object;
                              },
                          >;
                      },
                      any,
                      any,
                  > & { length: number };
                  unencoded_length: string | number | bigint;
              };
          };
          rootHash: Uint8Array<ArrayBufferLike>;
          sliversByNode: SliversForNode[];
      },
  >

  Usage

  const { blobId, metadata, sliversByNode, rootHash } = await client.encodeBlob(blob);
  Copy

executeCertifyBlobTransaction

• executeCertifyBlobTransaction(
      __namedParameters: CertifyBlobOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<{ digest: string }>

  Execute a transaction that certifies a blob

  Parameters

  • __namedParameters: CertifyBlobOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<{ digest: string }>

  Usage

  const { digest } = await client.executeCertifyBlobTransaction({ blobId, blobObjectId, confirmations, signer });
  Copy

executeCreateStorageTransaction

• executeCreateStorageTransaction(
      __namedParameters: StorageWithSizeOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<
      {
          digest: string;
          storage: {
              end_epoch: number;
              id: { id: string };
              start_epoch: number;
              storage_size: string;
          };
      },
  >

  Execute a transaction that creates a storage object

  Parameters

  • __namedParameters: StorageWithSizeOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<
      {
          digest: string;
          storage: {
              end_epoch: number;
              id: { id: string };
              start_epoch: number;
              storage_size: string;
          };
      },
  >

  Usage

  const { digest, storage } = await client.executeCreateStorageTransaction({ size: 1000, epochs: 3, signer });
  Copy

executeDeleteBlobTransaction

• executeDeleteBlobTransaction(
      __namedParameters: DeleteBlobOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<{ digest: string }>

  Execute a transaction that deletes a blob

  Parameters

  • __namedParameters: DeleteBlobOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<{ digest: string }>

  Usage

  const { digest } = await client.executeDeleteBlobTransaction({ blobObjectId, signer });
  Copy

executeExtendBlobTransaction

• executeExtendBlobTransaction(
      __namedParameters: ExtendBlobOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<{ digest: string }>

  Execute a transaction that extends a blob

  Parameters

  • __namedParameters: ExtendBlobOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<{ digest: string }>

  Usage

  const { digest } = await client.executeExtendBlobTransaction({ blobObjectId, signer });
  Copy

executeRegisterBlobTransaction

• executeRegisterBlobTransaction(
      __namedParameters: RegisterBlobOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<
      {
          blob: {
              blob_id: string;
              certified_epoch: null
              | number;
              deletable: boolean;
              encoding_type: number;
              id: { id: string };
              registered_epoch: number;
              size: string;
              storage: {
                  end_epoch: number;
                  id: { id: string };
                  start_epoch: number;
                  storage_size: string;
              };
          };
          digest: string;
      },
  >

  Execute a transaction that registers a blob

  Parameters

  • __namedParameters: RegisterBlobOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<
      {
          blob: {
              blob_id: string;
              certified_epoch: null
              | number;
              deletable: boolean;
              encoding_type: number;
              id: { id: string };
              registered_epoch: number;
              size: string;
              storage: {
                  end_epoch: number;
                  id: { id: string };
                  start_epoch: number;
                  storage_size: string;
              };
          };
          digest: string;
      },
  >

  Usage

  const { digest, blob } = await client.executeRegisterBlobTransaction({ size: 1000, epochs: 3, signer });
  Copy

executeWriteBlobAttributesTransaction

• executeWriteBlobAttributesTransaction(
      __namedParameters: WriteBlobAttributesOptions & {
          signer: Signer;
          transaction?: Transaction;
      },
  ): Promise<{ digest: string }>

  Execute a transaction that writes attributes to a blob

  If attributes already exists, their previous values will be overwritten If an attribute is set to null, it will be removed from the blob

  Parameters

  • __namedParameters: WriteBlobAttributesOptions & { signer: Signer; transaction?: Transaction }

  Returns Promise<{ digest: string }>

  Usage

  const { digest } = await client.executeWriteBlobAttributesTransaction({ blobObjectId, signer });
  Copy

extendBlob

• extendBlob(
      __namedParameters: ExtendBlobOptions,
  ): Promise<(_tx: Transaction) => void>

  Extend a blob in a transaction

  Parameters

  • __namedParameters: ExtendBlobOptions

  Returns Promise<(_tx: Transaction) => void>

  Usage

  const tx = await client.extendBlobTransaction({ blobObjectId, epochs });
  Copy

extendBlobTransaction

• extendBlobTransaction(
      __namedParameters: ExtendBlobOptions & { transaction?: Transaction },
  ): Promise<Transaction>

  Create a transaction that extends a blob

  Parameters

  • __namedParameters: ExtendBlobOptions & { transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.extendBlobTransaction({ blobObjectId, epochs });
  Copy

getBlobMetadata

• getBlobMetadata(
      __namedParameters: ReadBlobOptions,
  ): Promise<
      {
          blob_id: string;
          metadata: {
              $kind: "V1";
              V1: {
                  encoding_type: EnumOutputShapeWithKeys<
                      { RedStuff: true; RS2: true },
                      "RedStuff" | "RS2",
                  >;
                  hashes: {
                      primary_hash: EnumOutputShapeWithKeys<
                          { Digest: Uint8Array<ArrayBufferLike>; Empty: true },
                          "Empty" | "Digest",
                      >;
                      secondary_hash: EnumOutputShapeWithKeys<
                          { Digest: Uint8Array<ArrayBufferLike>; Empty: true },
                          "Empty" | "Digest",
                      >;
                  }[];
                  unencoded_length: string;
              };
          };
      },
  >

  Parameters

  • __namedParameters: ReadBlobOptions

  Returns Promise<
      {
          blob_id: string;
          metadata: {
              $kind: "V1";
              V1: {
                  encoding_type: EnumOutputShapeWithKeys<
                      { RedStuff: true; RS2: true },
                      "RedStuff" | "RS2",
                  >;
                  hashes: {
                      primary_hash: EnumOutputShapeWithKeys<
                          { Digest: Uint8Array<ArrayBufferLike>; Empty: true },
                          "Empty" | "Digest",
                      >;
                      secondary_hash: EnumOutputShapeWithKeys<
                          { Digest: Uint8Array<ArrayBufferLike>; Empty: true },
                          "Empty" | "Digest",
                      >;
                  }[];
                  unencoded_length: string;
              };
          };
      },
  >

getBlobType

• getBlobType(): string | Promise<string>

  The Move type for a Blob object

  Returns string | Promise<string>

getSlivers

• getSlivers(
      __namedParameters: ReadBlobOptions,
  ): Promise<
      { index: number; symbols: { data: number[]; symbol_size: number } }[],
  >

  Parameters

  • __namedParameters: ReadBlobOptions

  Returns Promise<{ index: number; symbols: { data: number[]; symbol_size: number } }[]>

getStorageConfirmationFromNode

• getStorageConfirmationFromNode(
      __namedParameters: GetStorageConfirmationOptions,
  ): Promise<StorageConfirmation>

  Get a storage confirmation from a storage node

  Parameters

  • __namedParameters: GetStorageConfirmationOptions

  Returns Promise<StorageConfirmation>

  Usage

  const confirmation = await client.getStorageConfirmationFromNode({ nodeIndex, blobId, deletable, objectId });
  Copy

getVerifiedBlobStatus

• getVerifiedBlobStatus(__namedParameters: ReadBlobOptions): Promise<BlobStatus>

  Gets the blob status from multiple storage nodes and returns the latest status that can be verified.

  Parameters

  • __namedParameters: ReadBlobOptions

  Returns Promise<BlobStatus>

readBlobAttributes

• readBlobAttributes(
      __namedParameters: { blobObjectId: string },
  ): Promise<null | Record<string, string>>

  Parameters

  • __namedParameters: { blobObjectId: string }

  Returns Promise<null | Record<string, string>>

registerBlob

• registerBlob(
      __namedParameters: RegisterBlobOptions,
  ): Promise<(tx: Transaction) => TransactionResult>

  Register a blob in a transaction

  Parameters

  • __namedParameters: RegisterBlobOptions

  Returns Promise<(tx: Transaction) => TransactionResult>

  Usage

  tx.transferObjects([await client.registerBlob({ size: 1000, epochs: 3, blobId, rootHash, deletable: true })], owner);
  Copy

registerBlobTransaction

• registerBlobTransaction(
      __namedParameters: RegisterBlobOptions & { transaction?: Transaction },
  ): Promise<Transaction>

  Create a transaction that registers a blob

  Parameters

  • __namedParameters: RegisterBlobOptions & { transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.registerBlobTransaction({ size: 1000, epochs: 3, blobId, rootHash, deletable: true });
  Copy

reset

• reset(): void

  Reset cached data in the client

  Returns void

  Usage

  client.reset();
  Copy

stakingObject

• stakingObject(): Promise<
      {
          id: { id: string };
          new_package_id: null | string;
          package_id: string;
          version: string;
      },
  >

  The cached staking pool object for the walrus package

  Returns Promise<
      {
          id: { id: string };
          new_package_id: null | string;
          package_id: string;
          version: string;
      },
  >

stakingState

• stakingState(): Promise<
      {
          active_set: { id: { id: string } };
          committee: { pos0: { contents: { key: string; value: number[] }[] } };
          epoch: number;
          epoch_duration: string;
          epoch_state: EnumOutputShapeWithKeys<
              {
                  EpochChangeDone: string;
                  EpochChangeSync: number;
                  NextParamsSelected: string;
              },
              "EpochChangeSync"
              | "EpochChangeDone"
              | "NextParamsSelected",
          >;
          first_epoch_start: string;
          n_shards: number;
          next_committee:
              | null
              | { pos0: { contents: { key: string; value: number[] }[] } };
          next_epoch_params:
              | null
              | {
                  storage_price_per_unit_size: string;
                  total_capacity_size: string;
                  write_price_per_unit_size: string;
              };
          next_epoch_public_keys: { id: { id: string } };
          pools: { id: { id: string }; size: string };
          previous_committee: {
              pos0: { contents: { key: string; value: number[] }[] };
          };
      },
  >

  The staking state for the current version of walrus contract

  Returns Promise<
      {
          active_set: { id: { id: string } };
          committee: { pos0: { contents: { key: string; value: number[] }[] } };
          epoch: number;
          epoch_duration: string;
          epoch_state: EnumOutputShapeWithKeys<
              {
                  EpochChangeDone: string;
                  EpochChangeSync: number;
                  NextParamsSelected: string;
              },
              "EpochChangeSync"
              | "EpochChangeDone"
              | "NextParamsSelected",
          >;
          first_epoch_start: string;
          n_shards: number;
          next_committee:
              | null
              | { pos0: { contents: { key: string; value: number[] }[] } };
          next_epoch_params:
              | null
              | {
                  storage_price_per_unit_size: string;
                  total_capacity_size: string;
                  write_price_per_unit_size: string;
              };
          next_epoch_public_keys: { id: { id: string } };
          pools: { id: { id: string }; size: string };
          previous_committee: {
              pos0: { contents: { key: string; value: number[] }[] };
          };
      },
  >

storageCost

• storageCost(
      size: number,
      epochs: number,
  ): Promise<{ storageCost: bigint; totalCost: bigint; writeCost: bigint }>

  Calculate the cost of storing a blob for a given a size and number of epochs.

  Parameters

  • size: number
  • epochs: number

  Returns Promise<{ storageCost: bigint; totalCost: bigint; writeCost: bigint }>

systemObject

• systemObject(): Promise<
      {
          id: { id: string };
          new_package_id: null | string;
          package_id: string;
          version: string;
      },
  >

  The cached system object for the walrus package

  Returns Promise<
      {
          id: { id: string };
          new_package_id: null | string;
          package_id: string;
          version: string;
      },
  >

systemState

• systemState(): Promise<
      {
          committee: {
              epoch: number;
              members: {
                  node_id: string;
                  public_key: { bytes: number[] };
                  weight: number;
              }[];
              n_shards: number;
              total_aggregated_key: { bytes: number[] };
          };
          deny_list_sizes: { id: { id: string } };
          event_blob_certification_state: {
              aggregate_weight_per_blob: {
                  contents: {
                      key: { blob_id: string; ending_checkpoint_sequence_number: string };
                      value: number;
                  }[];
              };
              latest_certified_blob: | null
              | { blob_id: string; ending_checkpoint_sequence_number: string };
          };
          future_accounting: {
              current_index: number;
              length: number;
              ring_buffer: {
                  epoch: number;
                  rewards_to_distribute: { value: string };
                  used_capacity: string;
              }[];
          };
          storage_price_per_unit_size: string;
          total_capacity_size: string;
          used_capacity_size: string;
          write_price_per_unit_size: string;
      },
  >

  The system state for the current version of walrus contract

  Returns Promise<
      {
          committee: {
              epoch: number;
              members: {
                  node_id: string;
                  public_key: { bytes: number[] };
                  weight: number;
              }[];
              n_shards: number;
              total_aggregated_key: { bytes: number[] };
          };
          deny_list_sizes: { id: { id: string } };
          event_blob_certification_state: {
              aggregate_weight_per_blob: {
                  contents: {
                      key: { blob_id: string; ending_checkpoint_sequence_number: string };
                      value: number;
                  }[];
              };
              latest_certified_blob: | null
              | { blob_id: string; ending_checkpoint_sequence_number: string };
          };
          future_accounting: {
              current_index: number;
              length: number;
              ring_buffer: {
                  epoch: number;
                  rewards_to_distribute: { value: string };
                  used_capacity: string;
              }[];
          };
          storage_price_per_unit_size: string;
          total_capacity_size: string;
          used_capacity_size: string;
          write_price_per_unit_size: string;
      },
  >

writeBlob

• writeBlob(
      __namedParameters: WriteBlobOptions,
  ): Promise<
      {
          blobId: string;
          blobObject: {
              blob_id: string;
              certified_epoch: null
              | number;
              deletable: boolean;
              encoding_type: number;
              id: { id: string };
              registered_epoch: number;
              size: string;
              storage: {
                  end_epoch: number;
                  id: { id: string };
                  start_epoch: number;
                  storage_size: string;
              };
          };
      },
  >

  Write a blob to all storage nodes

  Parameters

  • __namedParameters: WriteBlobOptions

  Returns Promise<
      {
          blobId: string;
          blobObject: {
              blob_id: string;
              certified_epoch: null
              | number;
              deletable: boolean;
              encoding_type: number;
              id: { id: string };
              registered_epoch: number;
              size: string;
              storage: {
                  end_epoch: number;
                  id: { id: string };
                  start_epoch: number;
                  storage_size: string;
              };
          };
      },
  >

  Usage

  const { blobId, blobObject } = await client.writeBlob({ blob, deletable, epochs, signer });
  Copy

writeBlobAttributes

• writeBlobAttributes(
      __namedParameters: WriteBlobAttributesOptions,
  ): Promise<(tx: Transaction) => void>

  Write attributes to a blob

  If attributes already exists, their previous values will be overwritten If an attribute is set to null, it will be removed from the blob

  Parameters

  • __namedParameters: WriteBlobAttributesOptions

  Returns Promise<(tx: Transaction) => void>

  Usage

  tx.add(await client.writeBlobAttributes({ blobObjectId, attributes: { key: 'value', keyToRemove: null } }));
  Copy

writeBlobAttributesTransaction

• writeBlobAttributesTransaction(
      __namedParameters: WriteBlobAttributesOptions & {
          transaction?: Transaction;
      },
  ): Promise<Transaction>

  Create a transaction that writes attributes to a blob

  If attributes already exists, their previous values will be overwritten If an attribute is set to null, it will be removed from the blob

  Parameters

  • __namedParameters: WriteBlobAttributesOptions & { transaction?: Transaction }

  Returns Promise<Transaction>

  Usage

  const tx = await client.writeBlobAttributesTransaction({ blobObjectId, attributes: { key: 'value', keyToRemove: null } });
  Copy

writeEncodedBlobToNode

• writeEncodedBlobToNode(
      __namedParameters: WriteEncodedBlobOptions,
  ): Promise<StorageConfirmation>

  Write encoded blob to a storage node

  Parameters

  • __namedParameters: WriteEncodedBlobOptions

  Returns Promise<StorageConfirmation>

  Usage

  const res = await client.writeEncodedBlobToNode({ nodeIndex, blobId, metadata, slivers });
  Copy

writeEncodedBlobToNodes

• writeEncodedBlobToNodes(
      __namedParameters: WriteEncodedBlobToNodesOptions,
  ): Promise<(null | StorageConfirmation)[]>

  Write a blob to all storage nodes

  Parameters

  • __namedParameters: WriteEncodedBlobToNodesOptions

  Returns Promise<(null | StorageConfirmation)[]>

  Usage

  await client.writeEncodedBlobToNodes({ blob, deletable, epochs, signer });
  Copy

writeMetadataToNode

• writeMetadataToNode(
      __namedParameters: WriteMetadataOptions,
  ): Promise<StoreBlobMetadataResponse>

  Write metadata to a storage node

  Parameters

  • __namedParameters: WriteMetadataOptions

  Returns Promise<StoreBlobMetadataResponse>

  Usage

  const res = await client.writeMetadataToNode({ nodeIndex, blobId, metadata });
  Copy

writeSliver

• writeSliver(__namedParameters: WriteSliverOptions): Promise<StoreSliverResponse>

  Write a sliver to a storage node

  Parameters

  • __namedParameters: WriteSliverOptions

  Returns Promise<StoreSliverResponse>

  Usage

  const res = await client.writeSliver({ blobId, sliverPairIndex, sliverType, sliver });
  Copy

writeSliversToNode

• writeSliversToNode(__namedParameters: WriteSliversToNodeOptions): Promise<void>

  Write slivers to a storage node

  Parameters

  • __namedParameters: WriteSliversToNodeOptions

  Returns Promise<void>

  Usage

  await client.writeSliversToNode({ blobId, slivers, signal });
  Copy

Staticexperimental_asClientExtension

• experimental_asClientExtension(
      __namedParameters?: WalrusClientExtensionOptions,
  ): {
      name: "walrus";
      register: (
          client: ClientWithExtensions<{ jsonRpc: SuiClient }>,
      ) => WalrusClient;
  }

  Parameters

  • __namedParameters: WalrusClientExtensionOptions = {}

  Returns {
      name: "walrus";
      register: (
          client: ClientWithExtensions<{ jsonRpc: SuiClient }>,
      ) => WalrusClient;
  }