Documentation
    Preparing search index...

    Class WalrusClient

    Index

    Constructors

    constructor

    Properties

    getSecondarySliver readBlob

    Methods

    addAuthPayload calculateUploadRelayTip certificateFromConfirmations certifyBlob certifyBlobTransaction computeBlobMetadata createStorage createStorageTransaction deleteBlob deleteBlobTransaction encodeBlob encodeQuilt executeCertifyBlobTransaction executeCreateStorageTransaction executeDeleteBlobTransaction executeExtendBlobTransaction executeRegisterBlobTransaction executeWriteBlobAttributesTransaction extendBlob extendBlobTransaction getBlob getBlobMetadata getBlobObject getBlobType getFiles getSlivers getStorageConfirmationFromNode getStorageConfirmations getVerifiedBlobStatus internalGetSecondarySliver readBlobAttributes registerBlob registerBlobTransaction reset sendUploadRelayTip stakingObject stakingState storageCost systemObject systemState writeBlob writeBlobAttributes writeBlobAttributesTransaction writeBlobFlow writeBlobToUploadRelay writeEncodedBlobToNode writeEncodedBlobToNodes writeFiles writeFilesFlow writeMetadataToNode writeQuilt writeSliver writeSliversToNode

    Constructors

    Properties

    getSecondarySliver: (
        __namedParameters: GetSecondarySliverOptions,
    ) => Promise<GetSliverResponse> = ...
    readBlob: (
        __namedParameters: ReadBlobOptions,
    ) => Promise<Uint8Array<ArrayBufferLike>> = ...

    Read a blob from the storage nodes

    Methods

    • Parameters

      • __namedParameters: {
            blobDigest:
                | Uint8Array<ArrayBufferLike>
                | (() => Promise<Uint8Array<ArrayBufferLike>>);
            nonce: Uint8Array;
            size: number;
        }

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

    • Parameters

      • options: { size: number }

      Returns Promise<number | bigint>

    • Parameters

      • __namedParameters: { blobId: string; blobObjectId: string; deletable: boolean } & {
            certificate?: undefined;
            confirmations: (StorageConfirmation | null)[];
        }
        • blobId: string
        • blobObjectId: string
        • deletable: boolean
        • Optionalcertificate?: undefined
        • confirmations: (StorageConfirmation | null)[]

          An array of confirmations. These confirmations must be provided in the same order as the nodes in the committee. For nodes that have not provided a confirmation you can pass null

      Returns Promise<ProtocolMessageCertificate>

    • Certify a blob in a transaction

      Parameters

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

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

    • Parameters

      Returns Promise<
          {
              blobDigest: () => Promise<Uint8Array<ArrayBufferLike>>;
              blobId: string;
              metadata: { encodingType: EncodingType; unencodedLength: bigint };
              nonce: Uint8Array<ArrayBufferLike>;
              rootHash: Uint8Array<ArrayBufferLike>;
          },
      >

    • Create a transaction that creates a storage object

      Parameters

      Returns Transaction

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

    • Create a transaction that deletes a blob

      Parameters

      Returns Transaction

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

    • Encode a blob into slivers for each node

      Parameters

      • blob: Uint8Array

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

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

    • Parameters

      • __namedParameters: {
            blobs: {
                contents: Uint8Array;
                identifier: string;
                tags?: Record<string, string>;
            }[];
        }

      Returns Promise<
          {
              index: {
                  patches: (
                      {
                          endIndex: number;
                          identifier: string;
                          tags: Map<string, string>
                          | Record<string, string>;
                      } & { startIndex: number }
                  )[];
              };
              quilt: Uint8Array<ArrayBuffer>;
          },
      >

    • Execute a transaction that certifies a blob

      Parameters

      Returns Promise<{ digest: string }>

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

    • Execute a transaction that creates a storage object

      Parameters

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

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

    • Execute a transaction that deletes a blob

      Parameters

      Returns Promise<{ digest: string }>

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

    • Execute a transaction that extends a blob

      Parameters

      Returns Promise<{ digest: string }>

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

    • Execute a transaction that registers a blob

      Parameters

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

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

    • 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

      Returns Promise<{ digest: string }>

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

    • Extend a blob in a transaction

      Parameters

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

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

    • Create a transaction that extends a blob

      Parameters

      Returns Promise<Transaction>

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

    • Parameters

      • __namedParameters: { blobId: string }

      Returns Promise<WalrusBlob>

    • Parameters

      Returns Promise<
          {
              blobId: 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;
                  };
              };
          },
      >

    • Load a parsed Blob object from chain by its Sui object ID.

      Parameters

      • blobObjectId: string

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

      const blobObject = await client.getBlobObject('0x...');
      console.log(blobObject.id, blobObject.blob_id);

    • The Move type for a Blob object

      Returns string | Promise<string>

    • Parameters

      • __namedParameters: { ids: string[] }

      Returns Promise<WalrusFile[]>

    • Parameters

      Returns Promise<GetSliverResponse[]>

    • Get a storage confirmation from a storage node

      Parameters

      Returns Promise<StorageConfirmation>

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

    • Get storage confirmations from all active committee nodes for a blob. Useful for resuming after upload completed but certify crashed — re-fetches confirmations that can be passed to certifyBlobTransaction().

      Parameters

      • __namedParameters: { blobId: string; deletable: boolean; objectId?: string; signal?: AbortSignal }

      Returns Promise<(StorageConfirmation | null)[]>

      const confirmations = await client.getStorageConfirmations({
        blobId: savedState.blobId,
        deletable: true,
        objectId: savedState.blobObjectId,
      });
      const tx = client.certifyBlobTransaction({ blobId, blobObjectId, confirmations, deletable: true });

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

      Parameters

      Returns Promise<BlobStatus>

    • Parameters

      • __namedParameters: { blobObjectId: string }

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

    • Create a transaction that registers a blob

      Parameters

      Returns Transaction

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

    • Reset cached data in the client

      Returns void

      client.reset();

    • Parameters

      • __namedParameters: {
            blobDigest:
                | Uint8Array<ArrayBufferLike>
                | (() => Promise<Uint8Array<ArrayBufferLike>>);
            nonce: Uint8Array;
            size: number;
        }

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

    • The cached staking pool object for the walrus package

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

    • The staking state for the current version of walrus contract

      Returns Promise<
          {
              active_set: { id: string };
              committee: [{ 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: [{ contents: { key: string; value: number[] }[] }] | null;
              next_epoch_params:
                  | {
                      storage_price_per_unit_size: string;
                      total_capacity_size: string;
                      write_price_per_unit_size: string;
                  }
                  | null;
              next_epoch_public_keys: { id: string };
              pools: { id: string; size: string };
              previous_committee: [{ contents: { key: string; value: number[] }[] }];
          },
      >

    • 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 }>

    • The cached system object for the walrus package

      Returns Promise<
          {
              id: string;
              new_package_id: string
              | null;
              package_id: string;
              version: 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: string };
              event_blob_certification_state: {
                  aggregate_weight_per_blob: {
                      contents: {
                          key: { blob_id: string; ending_checkpoint_sequence_number: string };
                          value: number;
                      }[];
                  };
                  latest_certified_blob: | {
                      blob_id: string;
                      ending_checkpoint_sequence_number: string;
                  }
                  | null;
              };
              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;
          },
      >

    • Write a blob to all storage nodes

      Parameters

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

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

    • 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

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

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

    • 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

      Returns Promise<Transaction>

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

    • Create a step-by-step blob upload flow with resume support.

      Returns an object with individual step methods (encode, register, upload, certify) for manual control, convenience methods (executeRegister, executeCertify) that handle signing, and a run() async iterator that executes the full pipeline.

      Each step returns a WriteBlobStep result that can be persisted and passed as resume to recover from crashes.

      Parameters

      Returns WriteBlobFlow

      // Async iterator with checkpoints:
      const flow = client.writeBlobFlow({ blob });
      for await (const step of flow.run({ signer, epochs: 3, deletable: true })) {
        await db.save(fileId, step);
      }

      // Resume from saved state:
      const saved = await db.load(fileId);
      const flow = client.writeBlobFlow({ blob, resume: saved });
      for await (const step of flow.run({ signer, epochs: 3, deletable: true })) {
        await db.save(fileId, step);
      }

    • Write encoded blob to a storage node

      Parameters

      Returns Promise<StorageConfirmation>

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

    • Write a blob to all storage nodes

      Parameters

      Returns Promise<(StorageConfirmation | null)[]>

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

    • Parameters

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

    • Create a step-by-step files upload flow with resume support.

      Encodes files into a quilt blob and delegates to writeBlobFlow() internally. Supports the same resume, step methods, and run() async iterator as writeBlobFlow().

      Parameters

      Returns WriteFilesFlow

      const flow = client.writeFilesFlow({ files });
      for await (const step of flow.run({ signer, epochs: 3, deletable: true })) {
        await db.save(fileId, step);
      }
      const fileRefs = await flow.listFiles();

    • Write metadata to a storage node

      Parameters

      Returns Promise<StoreBlobMetadataResponse>

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

    • Parameters

      Returns Promise<
          {
              blobId: string;
              blobObject: {
                  blob_id: string;
                  certified_epoch: number
                  | null;
                  deletable: boolean;
                  encoding_type: number;
                  id: string;
                  registered_epoch: number;
                  size: string;
                  storage: {
                      end_epoch: number;
                      id: string;
                      start_epoch: number;
                      storage_size: string;
                  };
              };
              index: {
                  patches: {
                      endIndex: number;
                      identifier: string;
                      patchId: string;
                      startIndex: number;
                      tags: Map<string, string>
                      | Record<string, string>;
                  }[];
              };
          },
      >

    • Write a sliver to a storage node

      Parameters

      Returns Promise<StoreSliverResponse>

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

    • Write slivers to a storage node

      Parameters

      Returns Promise<void>

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

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods
    addAuthPayloadcalculateUploadRelayTipcertificateFromConfirmationscertifyBlobcertifyBlobTransactioncomputeBlobMetadatacreateStoragecreateStorageTransactiondeleteBlobdeleteBlobTransactionencodeBlobencodeQuiltexecuteCertifyBlobTransactionexecuteCreateStorageTransactionexecuteDeleteBlobTransactionexecuteExtendBlobTransactionexecuteRegisterBlobTransactionexecuteWriteBlobAttributesTransactionextendBlobextendBlobTransactiongetBlobgetBlobMetadatagetBlobObjectgetBlobTypegetFilesgetSliversgetStorageConfirmationFromNodegetStorageConfirmationsgetVerifiedBlobStatusinternalGetSecondarySliverreadBlobAttributesregisterBlobregisterBlobTransactionresetsendUploadRelayTipstakingObjectstakingStatestorageCostsystemObjectsystemStatewriteBlobwriteBlobAttributeswriteBlobAttributesTransactionwriteBlobFlowwriteBlobToUploadRelaywriteEncodedBlobToNodewriteEncodedBlobToNodeswriteFileswriteFilesFlowwriteMetadataToNodewriteQuiltwriteSliverwriteSliversToNode