diff --git a/.changeset/silent-crews-cover.md b/.changeset/silent-crews-cover.md
new file mode 100644
index 00000000..927cffb6
--- /dev/null
+++ b/.changeset/silent-crews-cover.md
@@ -0,0 +1,5 @@
+---
+'@bnb-chain/greenfield-js-sdk': patch
+---
+
+feat: Uploading Object support resumable
diff --git a/examples/nextjs/src/components/object/create/index.tsx b/examples/nextjs/src/components/object/create/index.tsx
index d513a700..987781a8 100644
--- a/examples/nextjs/src/components/object/create/index.tsx
+++ b/examples/nextjs/src/components/object/create/index.tsx
@@ -105,7 +105,7 @@ export const CreateObject = () => {
         </button>{' '}
         <button
           onClick={async () => {
-            if (!address || !file || !txHash) return;
+            if (!address || !file) return;
             console.log(file);
 
             const provider = await connector?.getProvider();
@@ -136,10 +136,83 @@ export const CreateObject = () => {
             }
           }}
         >
-          2. upload
+          * upload
+        </button>{' '}
+        <button
+          onClick={async () => {
+            if (!address || !file) return;
+
+            const provider = await connector?.getProvider();
+            const offChainData = await getOffchainAuthKeys(address, provider);
+            if (!offChainData) {
+              alert('No offchain, please create offchain pairs first');
+              return;
+            }
+
+            const uploadRes = await client.object.uploadObject(
+              {
+                bucketName: createObjectInfo.bucketName,
+                objectName: createObjectInfo.objectName,
+                body: file,
+                resumableOpts: {
+                  partSize: 1024 * 1024 * 16,
+                  disableResumable: false,
+                },
+              },
+              {
+                type: 'EDDSA',
+                domain: window.location.origin,
+                seed: offChainData.seedString,
+                address,
+              },
+            );
+            console.log('uploadRes', uploadRes);
+
+            if (uploadRes.code === 0) {
+              alert('success');
+            }
+          }}
+        >
+          * resumable upload(part size is 16MB)
         </button>
         <br />
-        or uploaded by delegated agent
+        or uploaded by delegated agent :{' '}
+        <button
+          onClick={async () => {
+            if (!address || !file) return;
+
+            const provider = await connector?.getProvider();
+            const offChainData = await getOffchainAuthKeys(address, provider);
+            if (!offChainData) {
+              alert('No offchain, please create offchain pairs first');
+              return;
+            }
+
+            const uploadRes = await client.object.delegateUploadObject(
+              {
+                bucketName: createObjectInfo.bucketName,
+                objectName: createObjectInfo.objectName,
+                body: file,
+                delegatedOpts: {
+                  visibility: VisibilityType.VISIBILITY_TYPE_PUBLIC_READ,
+                },
+              },
+              {
+                type: 'EDDSA',
+                domain: window.location.origin,
+                seed: offChainData.seedString,
+                address,
+              },
+            );
+            console.log('uploadRes', uploadRes);
+
+            if (uploadRes.code === 0) {
+              alert('success');
+            }
+          }}
+        >
+          * delegated upload
+        </button>{' '}
         <button
           onClick={async () => {
             if (!address || !file) return;
@@ -156,7 +229,13 @@ export const CreateObject = () => {
                 bucketName: createObjectInfo.bucketName,
                 objectName: createObjectInfo.objectName,
                 body: file,
-                visibility: VisibilityType.VISIBILITY_TYPE_PUBLIC_READ,
+                delegatedOpts: {
+                  visibility: VisibilityType.VISIBILITY_TYPE_PUBLIC_READ,
+                },
+                resumableOpts: {
+                  partSize: 1024 * 1024 * 16,
+                  disableResumable: false,
+                },
               },
               {
                 type: 'EDDSA',
@@ -172,7 +251,35 @@ export const CreateObject = () => {
             }
           }}
         >
-          delegated upload
+          * delegated resumable upload (part size is 16mb)
+        </button>
+        <br />
+        <button
+          onClick={async () => {
+            if (!address) return;
+
+            const provider = await connector?.getProvider();
+            const offChainData = await getOffchainAuthKeys(address, provider);
+            if (!offChainData) {
+              alert('No offchain, please create offchain pairs first');
+              return;
+            }
+
+            const res = await client.object.getObjectUploadProgress(
+              createObjectInfo.bucketName,
+              createObjectInfo.objectName,
+              {
+                type: 'EDDSA',
+                domain: window.location.origin,
+                seed: offChainData.seedString,
+                address,
+              },
+            );
+
+            alert('progress: ' + res);
+          }}
+        >
+          get object's upload progress
         </button>
         <br />
         <button
diff --git a/packages/js-sdk/src/api/bucket.ts b/packages/js-sdk/src/api/bucket.ts
index 174d099b..758aa468 100644
--- a/packages/js-sdk/src/api/bucket.ts
+++ b/packages/js-sdk/src/api/bucket.ts
@@ -1,4 +1,10 @@
-import { MsgToggleSPAsDelegatedAgentSDKTypeEIP712 } from '@/messages/greenfield/storage/MsgToggleSpAsDelegatedAgent';
+import {
+  MsgToggleSPAsDelegatedAgentSDKTypeEIP712,
+  MsgCreateBucketSDKTypeEIP712,
+  MsgDeleteBucketSDKTypeEIP712,
+  MsgMigrateBucketSDKTypeEIP712,
+  MsgUpdateBucketInfoSDKTypeEIP712,
+} from '@/messages/greenfield';
 import { assertAuthType, assertStringRequire } from '@/utils/asserts/params';
 import { UInt64Value } from '@bnb-chain/greenfield-cosmos-types/greenfield/common/wrapper';
 import {
@@ -73,10 +79,6 @@ import {
 import { SpClient } from '../clients/spclient/spClient';
 import { TxClient } from '../clients/txClient';
 import { METHOD_GET, NORMAL_ERROR_CODE } from '../constants/http';
-import { MsgCreateBucketSDKTypeEIP712 } from '../messages/greenfield/storage/MsgCreateBucket';
-import { MsgDeleteBucketSDKTypeEIP712 } from '../messages/greenfield/storage/MsgDeleteBucket';
-import { MsgMigrateBucketSDKTypeEIP712 } from '../messages/greenfield/storage/MsgMigrateBucket';
-import { MsgUpdateBucketInfoSDKTypeEIP712 } from '../messages/greenfield/storage/MsgUpdateBucketInfo';
 import type {
   GetBucketMetaRequest,
   GetBucketMetaResponse,
diff --git a/packages/js-sdk/src/api/objects.ts b/packages/js-sdk/src/api/objects.ts
index 08d91285..0918e661 100644
--- a/packages/js-sdk/src/api/objects.ts
+++ b/packages/js-sdk/src/api/objects.ts
@@ -1,3 +1,13 @@
+import {
+  getObjectOffsetInfo,
+  parseObjectOffsetResponse,
+} from '@/clients/spclient/spApis/getObjectOffset';
+import {
+  getObjectStatusInfo,
+  parseObjectStatusResponse,
+} from '@/clients/spclient/spApis/getObjectStatus';
+import { getResumablePutObjectMetaInfo } from '@/clients/spclient/spApis/resumablePutObject';
+import { UploadProgressResponse } from '@/types/sp/UploadProgress';
 import { assertAuthType, assertStringRequire } from '@/utils/asserts/params';
 import {
   ActionType,
@@ -26,6 +36,7 @@ import { ed25519 } from '@noble/curves/ed25519';
 import { Headers } from 'cross-fetch';
 import { container, delay, inject, injectable } from 'tsyringe';
 import {
+  DEFAULT_PART_SIZE,
   GRNToString,
   MsgCancelCreateObjectTypeUrl,
   MsgCreateObjectTypeUrl,
@@ -72,13 +83,15 @@ import {
   ListObjectsByIDsRequest,
   ListObjectsByIDsResponse,
   Long,
+  ObjectStatus,
   SpResponse,
   TxResponse,
+  UploadOffsetResponse,
 } from '../types';
 import { GetObjectRequest } from '../types/sp/GetObject';
 import { GetObjectMetaRequest, GetObjectMetaResponse } from '../types/sp/GetObjectMeta';
 import { ListObjectsByBucketNameResponse } from '../types/sp/ListObjectsByBucketName';
-import { DelegatedPubObjectRequest, PutObjectRequest } from '../types/sp/PutObject';
+import { DelegatedOpts, DelegatedPubObjectRequest, PutObjectRequest } from '../types/sp/PutObject';
 import {
   checkObjectName,
   generateUrlByBucketName,
@@ -166,6 +179,15 @@ export interface IObject {
   listObjectPolicies(
     params: GetListObjectPoliciesRequest,
   ): Promise<SpResponse<GetListObjectPoliciesResponse>>;
+
+  /**
+   * return the status of object including the uploading progress
+   */
+  getObjectUploadProgress(
+    bucketName: string,
+    objectName: string,
+    authType: AuthType,
+  ): Promise<string>;
 }
 
 @injectable()
@@ -212,29 +234,140 @@ export class Objects implements IObject {
   }
 
   public async delegateUploadObject(params: DelegatedPubObjectRequest, authType: AuthType) {
-    const {
+    const { bucketName, objectName, body, resumableOpts, timeout = 30000, delegatedOpts } = params;
+
+    assertAuthType(authType);
+    verifyBucketName(bucketName);
+    verifyObjectName(objectName);
+
+    const disableResumable = resumableOpts?.disableResumable ?? true;
+    const partSize = resumableOpts?.partSize ?? DEFAULT_PART_SIZE;
+
+    let endpoint = params.endpoint;
+    if (!endpoint) {
+      endpoint = await this.sp.getSPUrlByBucket(bucketName);
+    }
+
+    const { params: storageParams } = await this.storage.params();
+    const maxSegmentSize = storageParams.versionedParams.maxSegmentSize.toNumber();
+
+    if (partSize % maxSegmentSize !== 0) {
+      throw new Error(
+        'partSize should be an integer multiple of the segment size: ' + maxSegmentSize,
+      );
+    }
+
+    if (body.size <= partSize || disableResumable) {
+      return this.putObject({
+        endpoint,
+        bucketName,
+        objectName,
+        body,
+        authType,
+        delegatedOpts,
+        timeout,
+        txnHash: '',
+      });
+    }
+
+    return await this.putResumableObject(
+      endpoint,
       bucketName,
       objectName,
       body,
-      contentType = body.type,
-      timeout = 5000,
-      visibility,
-    } = params;
+      partSize,
+      authType,
+      delegatedOpts,
+    );
+  }
+
+  public async uploadObject(
+    params: PutObjectRequest,
+    authType: AuthType,
+  ): Promise<SpResponse<null>> {
+    const { bucketName, objectName, body, duration = 30000, resumableOpts } = params;
+    assertAuthType(authType);
     verifyBucketName(bucketName);
     verifyObjectName(objectName);
-    assertAuthType(authType);
+
     let endpoint = params.endpoint;
     if (!endpoint) {
       endpoint = await this.sp.getSPUrlByBucket(bucketName);
     }
 
+    let txnHash = params.txnHash;
+    if (!txnHash) {
+      const { body } = await this.getObjectMeta({
+        bucketName,
+        objectName,
+        endpoint,
+      });
+      txnHash = body.GfSpGetObjectMetaResponse.Object.CreateTxHash;
+    }
+
+    const { params: storageParams } = await this.storage.params();
+
+    const maxSegmentSize = storageParams.versionedParams.maxSegmentSize.toNumber();
+
+    const disableResumable = resumableOpts?.disableResumable ?? true;
+    const partSize = resumableOpts?.partSize ?? DEFAULT_PART_SIZE;
+
+    if (partSize % maxSegmentSize !== 0) {
+      throw new Error(
+        'partSize should be an integer multiple of the segment size: ' + maxSegmentSize,
+      );
+    }
+
+    if (body.size <= partSize || disableResumable) {
+      return this.putObject({
+        endpoint,
+        bucketName,
+        objectName,
+        body,
+        txnHash,
+        authType,
+        timeout: duration,
+      });
+    }
+
+    return await this.putResumableObject(
+      endpoint,
+      bucketName,
+      objectName,
+      body,
+      partSize,
+      authType,
+    );
+  }
+
+  private async putObject(params: {
+    endpoint: string;
+    bucketName: string;
+    objectName: string;
+    body: File;
+    txnHash: string;
+    authType: AuthType;
+    delegatedOpts?: DelegatedOpts;
+    timeout: number;
+  }): Promise<SpResponse<null>> {
+    const {
+      authType,
+      body,
+      bucketName,
+      delegatedOpts,
+      timeout: duration,
+      endpoint,
+      objectName,
+      txnHash,
+    } = params;
+
     const { reqMeta, optionsWithOutHeaders, url } = await getPutObjectMetaInfo(endpoint, {
       bucketName,
       objectName,
-      contentType,
+      contentType: body.type,
+      txnHash,
       body,
-      visibility,
-      delegated: true,
+      delegatedOpts,
     });
     const signHeaders = await this.spClient.signHeaders(reqMeta, authType);
 
@@ -245,7 +378,7 @@ export class Objects implements IObject {
           ...optionsWithOutHeaders,
           headers: signHeaders,
         },
-        timeout,
+        duration,
       );
       const { status } = result;
 
@@ -259,28 +392,136 @@ export class Objects implements IObject {
     }
   }
 
-  public async uploadObject(
-    params: PutObjectRequest,
+  private splitPartInfo(objectSize: number, configuredPartSize: number) {
+    const partSizeFlt = configuredPartSize;
+    // Total parts count.
+    const totalPartsCount = Math.ceil(objectSize / partSizeFlt);
+    // Part size.
+    const partSize = partSizeFlt;
+    // Last part size.
+    const lastPartSize = objectSize - (totalPartsCount - 1) * partSize;
+    return {
+      totalPartsCount,
+      partSize,
+      lastPartSize,
+    };
+  }
+
+  private async putResumableObject(
+    endpoint: string,
+    bucketName: string,
+    objectName: string,
+    body: File,
+    partSize: number,
     authType: AuthType,
-  ): Promise<SpResponse<null>> {
-    assertAuthType(authType);
-    const { bucketName, objectName, txnHash, body, duration = 30000 } = params;
-    verifyBucketName(bucketName);
-    verifyObjectName(objectName);
-    assertStringRequire(txnHash, 'Transaction hash is empty, please check.');
+    delegatedOpts?: DelegatedOpts,
+  ) {
+    let offset = 0;
+    if (!delegatedOpts) {
+      const isObjectExist = await this.headSPObjectInfo(bucketName, objectName, authType);
+      if (!isObjectExist) {
+        throw new Error('Object does not exist');
+      }
 
-    let endpoint = params.endpoint;
-    if (!endpoint) {
-      endpoint = await this.sp.getSPUrlByBucket(bucketName);
+      offset = await this.getObjectResumableUploadOffset(bucketName, objectName, authType);
     }
-    const { reqMeta, optionsWithOutHeaders, url } = await getPutObjectMetaInfo(endpoint, {
+
+    const { totalPartsCount } = this.splitPartInfo(body.size, partSize);
+
+    // split file
+    const chunks = [];
+    for (let i = 0; i < totalPartsCount; i++) {
+      const start = i * partSize;
+      const end = Math.min(start + partSize, body.size);
+      const chunk = body.slice(start, end);
+      chunks.push(chunk);
+    }
+
+    let startPartNumber = offset / partSize;
+    while (startPartNumber < totalPartsCount) {
+      const chunkFile = new File([chunks[startPartNumber]], '');
+
+      const { reqMeta, optionsWithOutHeaders, url } = await getResumablePutObjectMetaInfo(
+        endpoint,
+        {
+          bucketName,
+          objectName,
+          contentType: body.type,
+          body: chunkFile,
+          offset: startPartNumber * partSize,
+          complete: startPartNumber === totalPartsCount - 1,
+          delegatedOpts,
+        },
+      );
+
+      const signHeaders = await this.spClient.signHeaders(reqMeta, authType);
+
+      try {
+        await this.spClient.callApi(
+          url,
+          {
+            ...optionsWithOutHeaders,
+            headers: signHeaders,
+          },
+          30000,
+        );
+      } catch (error: any) {
+        return {
+          code: -1,
+          message: error.message,
+          statusCode: error?.statusCode || NORMAL_ERROR_CODE,
+        };
+      } finally {
+        startPartNumber++;
+      }
+    }
+
+    return { code: 0, message: 'Put all object parts success.', statusCode: 200 };
+  }
+
+  private async headSPObjectInfo(bucketName: string, objectName: string, authType: AuthType) {
+    const { code } = await this.getObjectStatusFromSp(bucketName, objectName, authType);
+
+    if (code === 0) {
+      return true;
+    }
+
+    return false;
+  }
+
+  private async getObjectResumableUploadOffset(
+    bucketName: string,
+    objectName: string,
+    authType: AuthType,
+  ) {
+    const { objectInfo } = await this.headObject(bucketName, objectName);
+    if (!objectInfo) {
+      throw new Error('Object not found');
+    }
+
+    if (objectInfo.objectStatus == ObjectStatus.OBJECT_STATUS_CREATED) {
+      const { code, body } = await this.getObjectOffsetFromSP(bucketName, objectName, authType);
+
+      if (body) {
+        return body.QueryResumeOffset.Offset;
+      }
+    }
+
+    return 0;
+  }
+
+  private async getObjectOffsetFromSP(
+    bucketName: string,
+    objectName: string,
+    authType: AuthType,
+  ): Promise<SpResponse<UploadOffsetResponse>> {
+    const endpoint = await this.sp.getSPUrlByBucket(bucketName);
+
+    const { url, optionsWithOutHeaders, reqMeta } = await getObjectOffsetInfo(endpoint, {
       bucketName,
       objectName,
-      contentType: body.type,
-      txnHash,
-      body,
-      delegated: false,
     });
+
     const signHeaders = await this.spClient.signHeaders(reqMeta, authType);
 
     try {
@@ -290,11 +531,94 @@ export class Objects implements IObject {
           ...optionsWithOutHeaders,
           headers: signHeaders,
         },
-        duration,
+        5000,
       );
+      // console.log('upload-context result', result);
       const { status } = result;
 
-      return { code: 0, message: 'Put object success.', statusCode: status };
+      if (!result.ok) {
+        const xmlError = await result.text();
+        const { code, message } = await parseError(xmlError);
+        return {
+          code: code || -1,
+          message: message || 'error',
+          statusCode: status,
+          body: {
+            QueryResumeOffset: {
+              Offset: 0,
+            },
+          },
+        };
+      }
+
+      const xmlData = await result.text();
+      const res = parseObjectOffsetResponse(xmlData);
+
+      return { code: 0, message: 'get upload offset success', statusCode: status, body: res };
+    } catch (error: any) {
+      // console.log('err', error);
+      const message = error.message;
+
+      if (message.includes('no uploading record')) {
+        return {
+          code: -1,
+          message: message,
+          statusCode: error.code,
+          body: {
+            QueryResumeOffset: {
+              Offset: 0,
+            },
+          },
+        };
+      }
+      return {
+        code: -1,
+        message: error.message,
+        statusCode: error?.statusCode || NORMAL_ERROR_CODE,
+      };
+    }
+  }
+
+  private async getObjectStatusFromSp(
+    bucketName: string,
+    objectName: string,
+    authType: AuthType,
+  ): Promise<SpResponse<UploadProgressResponse>> {
+    const endpoint = await this.sp.getSPUrlByBucket(bucketName);
+
+    const { url, optionsWithOutHeaders, reqMeta } = await getObjectStatusInfo(endpoint, {
+      bucketName,
+      objectName,
+    });
+
+    const signHeaders = await this.spClient.signHeaders(reqMeta, authType);
+
+    try {
+      const result = await this.spClient.callApi(
+        url,
+        {
+          ...optionsWithOutHeaders,
+          headers: signHeaders,
+        },
+        5000,
+      );
+      // console.log('upload-progress result', result);
+      const { status } = result;
+
+      if (!result.ok) {
+        const xmlError = await result.text();
+        const { code, message } = await parseError(xmlError);
+        throw {
+          code: code || -1,
+          message: message || 'error',
+          statusCode: status,
+        };
+      }
+
+      const xmlData = await result.text();
+      const res = parseObjectStatusResponse(xmlData);
+
+      return { code: 0, message: 'success', statusCode: status, body: res };
     } catch (error: any) {
       return {
         code: -1,
@@ -708,4 +1032,24 @@ export class Objects implements IObject {
       body: res,
     };
   }
+
+  public async getObjectUploadProgress(bucketName: string, objectName: string, authType: AuthType) {
+    const { objectInfo } = await this.headObject(bucketName, objectName);
+
+    if (!objectInfo) {
+      throw new Error('object not exist');
+    }
+
+    if (objectInfo.objectStatus == ObjectStatus.OBJECT_STATUS_CREATED) {
+      const { body, message } = await this.getObjectStatusFromSp(bucketName, objectName, authType);
+
+      if (!body) {
+        throw new Error('fail to fetch object uploading progress from sp ' + message);
+      }
+
+      return body.QueryUploadProgress.ProgressDescription;
+    }
+
+    return objectInfo.objectStatus.toString();
+  }
 }
diff --git a/packages/js-sdk/src/clients/spclient/spApis/getObjectOffset.ts b/packages/js-sdk/src/clients/spclient/spApis/getObjectOffset.ts
new file mode 100644
index 00000000..8a997d33
--- /dev/null
+++ b/packages/js-sdk/src/clients/spclient/spApis/getObjectOffset.ts
@@ -0,0 +1,56 @@
+import { EMPTY_STRING_SHA256, METHOD_GET } from '@/constants';
+import { ReqMeta, UploadOffsetResponse } from '@/types';
+import { generateUrlByBucketName } from '@/utils/asserts/s3';
+import { XMLParser } from 'fast-xml-parser';
+import { encodePath, getSortQueryParams } from '../auth';
+
+// Uploading object's offset
+export const getObjectOffsetInfo = async (
+  endpoint: string,
+  params: {
+    objectName: string;
+    bucketName: string;
+  },
+) => {
+  const { bucketName, objectName } = params;
+  const path = `/${encodePath(objectName)}`;
+  const queryMap = {
+    'upload-context': '',
+  };
+
+  let url = new URL(path, generateUrlByBucketName(endpoint, bucketName));
+  url = getSortQueryParams(url, queryMap);
+
+  const reqMeta: Partial<ReqMeta> = {
+    contentSHA256: EMPTY_STRING_SHA256,
+    method: METHOD_GET,
+    url: {
+      hostname: new URL(url).hostname,
+      query: url.searchParams.toString(),
+      path,
+    },
+    contentType: 'application/octet-stream',
+  };
+
+  const optionsWithOutHeaders: Omit<RequestInit, 'headers'> = {
+    method: METHOD_GET,
+  };
+
+  return {
+    url: url.href,
+    optionsWithOutHeaders,
+    reqMeta,
+  };
+};
+
+export const parseObjectOffsetResponse = (data: string) => {
+  const xmlParser = new XMLParser({
+    parseTagValue: false,
+  });
+
+  const res = xmlParser.parse(data) as UploadOffsetResponse;
+
+  res.QueryResumeOffset.Offset = Number(res.QueryResumeOffset.Offset);
+
+  return res;
+};
diff --git a/packages/js-sdk/src/clients/spclient/spApis/getObjectStatus.ts b/packages/js-sdk/src/clients/spclient/spApis/getObjectStatus.ts
new file mode 100644
index 00000000..ed4f05b1
--- /dev/null
+++ b/packages/js-sdk/src/clients/spclient/spApis/getObjectStatus.ts
@@ -0,0 +1,55 @@
+import { EMPTY_STRING_SHA256, METHOD_GET } from '@/constants';
+import { ReqMeta } from '@/types';
+import { UploadProgressResponse } from '@/types/sp/UploadProgress';
+import { generateUrlByBucketName } from '@/utils/asserts/s3';
+import { XMLParser } from 'fast-xml-parser';
+import { encodePath, getSortQueryParams } from '../auth';
+
+// Object's upload-progress
+export const getObjectStatusInfo = async (
+  endpoint: string,
+  params: {
+    objectName: string;
+    bucketName: string;
+  },
+) => {
+  const { bucketName, objectName } = params;
+  const path = `/${encodePath(objectName)}`;
+  const queryMap = {
+    'upload-progress': '',
+  };
+
+  let url = new URL(path, generateUrlByBucketName(endpoint, bucketName));
+  url = getSortQueryParams(url, queryMap);
+
+  const reqMeta: Partial<ReqMeta> = {
+    contentSHA256: EMPTY_STRING_SHA256,
+    method: METHOD_GET,
+    url: {
+      hostname: new URL(url).hostname,
+      query: url.searchParams.toString(),
+      path,
+    },
+    // contentType: 'application/octet-stream',
+  };
+
+  const optionsWithOutHeaders: Omit<RequestInit, 'headers'> = {
+    method: METHOD_GET,
+  };
+
+  return {
+    url: url.href,
+    optionsWithOutHeaders,
+    reqMeta,
+  };
+};
+
+export const parseObjectStatusResponse = (data: string) => {
+  const xmlParser = new XMLParser({
+    parseTagValue: false,
+  });
+
+  const res = xmlParser.parse(data) as UploadProgressResponse;
+
+  return res;
+};
diff --git a/packages/js-sdk/src/clients/spclient/spApis/putObject.ts b/packages/js-sdk/src/clients/spclient/spApis/putObject.ts
index d652383c..f45fd687 100644
--- a/packages/js-sdk/src/clients/spclient/spApis/putObject.ts
+++ b/packages/js-sdk/src/clients/spclient/spApis/putObject.ts
@@ -11,29 +11,23 @@ export const getPutObjectMetaInfo = async (
     bucketName: string;
     contentType: string;
     body: File;
-    delegated?: boolean;
     txnHash?: string;
-    visibility?: VisibilityType;
+    delegatedOpts?: {
+      visibility: VisibilityType;
+      isUpdate?: boolean;
+    };
   },
 ) => {
-  const {
-    bucketName,
-    objectName,
-    txnHash,
-    contentType,
-    body,
-    delegated = false,
-    visibility = VisibilityType.VISIBILITY_TYPE_PRIVATE,
-  } = params;
+  const { bucketName, objectName, txnHash, contentType, body, delegatedOpts } = params;
   const path = `/${encodePath(objectName)}`;
   let queryMap = {};
 
-  if (delegated) {
+  if (delegatedOpts) {
     queryMap = {
       delegate: '',
-      is_update: 'false',
       payload_size: String(body.size),
-      visibility: visibility,
+      visibility: delegatedOpts.visibility.toString(),
+      is_update: String(delegatedOpts.isUpdate || false),
     };
   }
 
diff --git a/packages/js-sdk/src/clients/spclient/spApis/resumablePutObject.ts b/packages/js-sdk/src/clients/spclient/spApis/resumablePutObject.ts
new file mode 100644
index 00000000..9172aec4
--- /dev/null
+++ b/packages/js-sdk/src/clients/spclient/spApis/resumablePutObject.ts
@@ -0,0 +1,61 @@
+import { EMPTY_STRING_SHA256, METHOD_POST } from '@/constants';
+import { DelegatedOpts, ReqMeta } from '@/types';
+import { generateUrlByBucketName } from '@/utils/asserts/s3';
+import { encodePath, getSortQueryParams } from '../auth';
+
+// https://docs.bnbchain.org/greenfield-docs/docs/api/storage-provider-rest/resumable_put_object
+export const getResumablePutObjectMetaInfo = async (
+  endpoint: string,
+  params: {
+    objectName: string;
+    bucketName: string;
+    contentType: string;
+    body: File;
+    offset: number;
+    complete: boolean;
+    delegatedOpts?: DelegatedOpts;
+  },
+) => {
+  const { bucketName, objectName, contentType, body, offset, complete, delegatedOpts } = params;
+  const path = `/${encodePath(objectName)}`;
+  let queryMap: Record<string, string> = {
+    offset: String(offset),
+    complete: String(complete),
+  };
+
+  if (delegatedOpts) {
+    queryMap = {
+      ...queryMap,
+      delegate: '',
+      payload_size: String(body.size),
+      visibility: delegatedOpts.visibility.toString(),
+      is_update: String(delegatedOpts.isUpdate || false),
+    };
+  }
+
+  let url = new URL(path, generateUrlByBucketName(endpoint, bucketName));
+  url = getSortQueryParams(url, queryMap);
+
+  const reqMeta: Partial<ReqMeta> = {
+    contentSHA256: EMPTY_STRING_SHA256,
+    // txnHash: txnHash,
+    method: METHOD_POST,
+    url: {
+      hostname: url.hostname,
+      query: url.searchParams.toString(),
+      path,
+    },
+    contentType,
+  };
+
+  const optionsWithOutHeaders: Omit<RequestInit, 'headers'> = {
+    method: METHOD_POST,
+    body,
+  };
+
+  return {
+    url: url.href,
+    optionsWithOutHeaders,
+    reqMeta,
+  };
+};
diff --git a/packages/js-sdk/src/clients/spclient/spClient.ts b/packages/js-sdk/src/clients/spclient/spClient.ts
index 1d196cbe..195ae8e8 100644
--- a/packages/js-sdk/src/clients/spclient/spClient.ts
+++ b/packages/js-sdk/src/clients/spclient/spClient.ts
@@ -88,7 +88,7 @@ export class SpClient implements ISpClient {
 
       return response;
     } catch (error) {
-      return Promise.reject(error);
+      return Promise.reject(error + ': timeout, try to increase the request time');
     }
   }
 
diff --git a/packages/js-sdk/src/constants/index.ts b/packages/js-sdk/src/constants/index.ts
index d825b2fa..8d57ed27 100644
--- a/packages/js-sdk/src/constants/index.ts
+++ b/packages/js-sdk/src/constants/index.ts
@@ -3,3 +3,6 @@ export * from './http';
 
 export const ZERO_PUBKEY = '0x000000000000000000000000000000000000000000000000000000000000000000';
 export const DEFAULT_DENOM = 'BNB';
+
+// 32 MB
+export const DEFAULT_PART_SIZE = 1024 * 1024 * 32;
diff --git a/packages/js-sdk/src/messages/greenfield/index.ts b/packages/js-sdk/src/messages/greenfield/index.ts
index 880b316f..1aa4cfe0 100644
--- a/packages/js-sdk/src/messages/greenfield/index.ts
+++ b/packages/js-sdk/src/messages/greenfield/index.ts
@@ -14,10 +14,13 @@ export * from './storage/MsgDeleteGroup';
 export * from './storage/MsgDeleteObject';
 export * from './storage/MsgDeletePolicy';
 export * from './storage/MsgLeaveGroup';
+export * from './storage/MsgMigrateBucket';
 export * from './storage/MsgMirrorBucket';
 export * from './storage/MsgMirrorGroup';
 export * from './storage/MsgMirrorObject';
 export * from './storage/MsgPutPolicy';
+export * from './storage/MsgSetTag';
+export * from './storage/MsgToggleSPAsDelegatedAgent';
 export * from './storage/MsgUpdateBucketInfo';
 export * from './storage/MsgUpdateGroupExtra';
 export * from './storage/MsgUpdateGroupMember';
diff --git a/packages/js-sdk/src/types/sp/PutObject.ts b/packages/js-sdk/src/types/sp/PutObject.ts
index 855d1f6d..40ea0c1b 100644
--- a/packages/js-sdk/src/types/sp/PutObject.ts
+++ b/packages/js-sdk/src/types/sp/PutObject.ts
@@ -3,19 +3,30 @@ import { VisibilityType } from '../common';
 export type PutObjectRequest = {
   bucketName: string;
   objectName: string;
-  txnHash: string;
+  txnHash?: string;
   body: File;
   duration?: number;
   endpoint?: string;
-  delegated?: boolean;
+  resumableOpts?: ResumableOpts;
 };
 
 export type DelegatedPubObjectRequest = {
   bucketName: string;
   objectName: string;
   body: File;
-  visibility?: VisibilityType;
+  delegatedOpts: DelegatedOpts;
   endpoint?: string;
   timeout?: number;
   contentType?: string;
+  resumableOpts?: ResumableOpts;
+};
+
+export type DelegatedOpts = {
+  visibility: VisibilityType;
+  isUpdate?: boolean;
+};
+
+export type ResumableOpts = {
+  disableResumable: boolean;
+  partSize?: number;
 };
diff --git a/packages/js-sdk/src/types/sp/UploadOffset.ts b/packages/js-sdk/src/types/sp/UploadOffset.ts
new file mode 100644
index 00000000..c569c123
--- /dev/null
+++ b/packages/js-sdk/src/types/sp/UploadOffset.ts
@@ -0,0 +1,5 @@
+export interface UploadOffsetResponse {
+  QueryResumeOffset: {
+    Offset: number;
+  };
+}
diff --git a/packages/js-sdk/src/types/sp/UploadProgress.ts b/packages/js-sdk/src/types/sp/UploadProgress.ts
new file mode 100644
index 00000000..994adecb
--- /dev/null
+++ b/packages/js-sdk/src/types/sp/UploadProgress.ts
@@ -0,0 +1,6 @@
+export type UploadProgressResponse = {
+  QueryUploadProgress: {
+    ProgressDescription: string;
+    ErrorDescription: string;
+  };
+};
diff --git a/packages/js-sdk/src/types/sp/index.ts b/packages/js-sdk/src/types/sp/index.ts
index d5c701e2..266ef945 100644
--- a/packages/js-sdk/src/types/sp/index.ts
+++ b/packages/js-sdk/src/types/sp/index.ts
@@ -19,4 +19,6 @@ export * from './PutObject';
 export * from './ReadQuota';
 export * from './RequestNonce';
 export * from './SuccessResponse';
+export * from './UploadOffset';
+export * from './UploadProgress';
 export * from './VerifyPermission';