@zing-protocol/zing-sdk 0.0.1

package/src/components/index.ts

@@ -0,0 +1,3 @@
+export * from "./walrus-provider.js";
+export * from "./wallet-provider.js";
+export * from "./zing-provider.js";

package/src/components/wallet-provider.tsx

@@ -0,0 +1,53 @@
+// WalletProvider.tsx
+import { createWalletStore } from "../stores/walletStore.js";
+import { createContext, useContext, useRef, useEffect } from "react";
+import { useStore } from "zustand";
+import type { WalletStore, WalletStoreConfig } from "../stores/walletStore.js";
+import type { PropsWithChildren } from "react";
+import type { StoreApi } from "zustand";
+
+const WalletContext = createContext<StoreApi<WalletStore> | null>(null);
+
+export function WalletProvider({
+  suiClient,
+  oAuthClientId,
+  network,
+  autoInit = true,
+  children,
+}: PropsWithChildren<
+  WalletStoreConfig & { network?: string; autoInit?: boolean }
+>) {
+  const storeRef = useRef<StoreApi<WalletStore> | null>(null);
+
+  if (!storeRef.current) {
+    storeRef.current = createWalletStore({
+      suiClient,
+      oAuthClientId,
+      network,
+      autoInit,
+    });
+  }
+
+  // Optionally run initFromStorage when suiClient changes or on mount
+  useEffect(() => {
+    const s = storeRef.current!;
+    if (autoInit) {
+      s.getState()
+        .initFromStorage()
+        .catch(() => {});
+    }
+  }, [autoInit, suiClient]);
+
+  return (
+    <WalletContext.Provider value={storeRef.current}>
+      {children}
+    </WalletContext.Provider>
+  );
+}
+
+export function useWalletStore<T>(selector: (s: WalletStore) => T): T {
+  const store = useContext(WalletContext);
+  if (!store)
+    throw new Error("useWalletStore must be used inside WalletProvider");
+  return useStore(store, selector);
+}

package/src/components/walrus-provider.tsx

@@ -0,0 +1,212 @@
+import { calculateEncryptedQuiltSize } from "../lib/utils/quilt.js";
+import { uploadFileToWalrus } from "../mutations/walrus.js";
+import { createWalrusStore } from "../stores/walrusStore.js";
+import {
+  createContext,
+  useMemo,
+  useEffect,
+  useContext,
+  useCallback,
+} from "react";
+import { useStore } from "zustand";
+import type { PublishArticleEvent } from "../_generated/zing_studio/article.js";
+import type { ZingClient } from "../client/index.js";
+import type { WalrusUploadFlowStage } from "../config/common.js";
+import type { WalrusSystemState } from "../config/types.js";
+import type { QuiltSizeResult } from "../lib/utils/quilt.js";
+import type { WalrusStore } from "../stores/walrusStore.js";
+import type { ZKLoginSignerState } from "../types.js";
+import type { SealClient } from "@mysten/seal";
+import type { WalrusClient, WalrusFile } from "@mysten/walrus";
+import type { ReactNode } from "react";
+import type { StoreApi } from "zustand";
+
+type WalrusContextType = StoreApi<WalrusStore> & {
+  uploadFile: (
+    zingClient: ZingClient,
+    fileKey: CryptoKey,
+    walrusSystem: WalrusSystemState,
+    walTreasury: string,
+    storageByEpoch: Record<number, number>,
+    // params
+    walrusFiles: WalrusFile[],
+    subscriptionLevel: null | number,
+    metadata: {
+      identifier: string;
+      tags: {
+        "content-type": string;
+      };
+      size: number;
+    }[],
+    signer: ZKLoginSignerState,
+    gasPoolBearerToken: string,
+    onProgress?: (stage: WalrusUploadFlowStage) => void,
+  ) => Promise<typeof PublishArticleEvent.$inferType>;
+  calculateQuiltSize: (
+    walrusSystem: WalrusSystemState,
+    files: Array<{
+      size: number;
+      identifier: string;
+      tags?: Record<string, string>;
+    }>,
+    ivSize?: number,
+  ) => QuiltSizeResult;
+};
+
+const WalrusContext = createContext<WalrusContextType | undefined>(undefined);
+
+interface WalrusProviderProps {
+  walrusClient: WalrusClient;
+  sealClient: SealClient;
+  children: ReactNode;
+  // optional persistence
+  autoInit?: boolean;
+}
+
+export const WalrusProvider: React.FC<WalrusProviderProps> = ({
+  walrusClient,
+  sealClient,
+  children,
+  autoInit = true,
+}) => {
+  // create store instance once per provider
+  const store = useMemo(
+    () =>
+      createWalrusStore({
+        walrusClient,
+        sealClient,
+        autoInit,
+      }),
+    [walrusClient, sealClient, autoInit],
+  );
+
+  // optionally auto-init on mount
+  useEffect(() => {
+    if (autoInit) {
+      // call init and ignore errors � store handles them
+      store
+        .getState()
+        .init()
+        .catch((e: any) => {
+          console.error(e);
+          // optionally log
+          // console.error('Walrus store init failed', e);
+        });
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [store]);
+
+  const uploadFile = useCallback(
+    async (
+      zingClient: ZingClient,
+      fileKey: CryptoKey,
+      walrusSystem: WalrusSystemState,
+      walTreasury: string,
+      storageByEpoch: Record<number, number>,
+      walrusFiles: WalrusFile[],
+      subscriptionLevel: null | number,
+      metadata: {
+        identifier: string;
+        tags: {
+          "content-type": string;
+        };
+        size: number;
+      }[],
+      signer: ZKLoginSignerState,
+      gasPoolBearerToken: string,
+      onProgress?: (stage: WalrusUploadFlowStage) => void,
+    ) => {
+      const config = zingClient.config;
+      return uploadFileToWalrus(
+        {
+          zingStudioPackageId: config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          zingStudioV0PackageId: config.zing.ZING_STUDIO_V0_PACKAGE_ADDRESS,
+          walrusPackageId: config.walrus.WALRUS_PACKAGE,
+          zingStudioConfigSharedObjectRef:
+            config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+          walrusSystemSharedObjectRef:
+            config.walrus.WALRUS_SYSTEM_SHARED_OBJECT_REF,
+          zingStorageTreasurySharedObjectRef:
+            config.zing.ZING_STORAGE_TREASURY_SHARED_OBJECT_REF,
+          blobRegisteredEventType: config.walrus.EVENT_TYPES.blobRegistered,
+          publishArticleEventType: config.zing.EVENT_TYPES.publishArticleEvent,
+        },
+        zingClient.suiGrpcClient,
+        zingClient.suiJsonRpcClient,
+        walrusClient,
+        walrusSystem,
+        walTreasury,
+        storageByEpoch,
+        fileKey,
+        walrusFiles,
+        subscriptionLevel,
+        metadata,
+        signer,
+        gasPoolBearerToken,
+        onProgress,
+      );
+    },
+    [walrusClient],
+  );
+
+  const calculateQuiltSize = useCallback(
+    (
+      walrusSystem: WalrusSystemState,
+      files: Array<{
+        size: number;
+        identifier: string;
+        tags?: Record<string, string>;
+      }>,
+      ivSize: number = 12,
+    ): QuiltSizeResult => {
+      const numShards = walrusSystem.committee.n_shards;
+
+      return calculateEncryptedQuiltSize(
+        files,
+        numShards,
+        ivSize,
+        "RS2", // default encoding type
+      );
+    },
+    [],
+  );
+
+  // Memoize context value with uploadFile and calculateQuiltSize included
+  const contextValue = useMemo(
+    () =>
+      Object.assign(store, {
+        uploadFile,
+        calculateQuiltSize,
+      }) as WalrusContextType,
+    [store, uploadFile, calculateQuiltSize],
+  );
+
+  return (
+    <WalrusContext.Provider value={contextValue}>
+      {children}
+    </WalrusContext.Provider>
+  );
+};
+
+export function useWalrusStore<T>(selector: (s: WalrusStore) => T): T {
+  const store = useContext(WalrusContext);
+  if (!store) throw new Error("useWalrus must be used inside WalrusProvider");
+  return useStore(store, selector);
+}
+
+export function useWalrusUpload() {
+  const context = useContext(WalrusContext);
+  if (!context)
+    throw new Error("useWalrusUpload must be used inside WalrusProvider");
+
+  return context.uploadFile;
+}
+
+export function useWalrusQuiltSize() {
+  const context = useContext(WalrusContext);
+  if (!context)
+    throw new Error("useWalrusQuiltSize must be used inside WalrusProvider");
+
+  return context.calculateQuiltSize;
+}

package/src/components/zing-provider.tsx

@@ -0,0 +1,54 @@
+import { ZingClient } from "../client/index.js";
+import { createContext, useContext, useMemo } from "react";
+import type { SuiNetwork } from "../types.js";
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+import type { ReactNode } from "react";
+
+interface ZingClientContextProps {
+  client: ZingClient | null;
+}
+
+const ZingClientContext = createContext<ZingClientContextProps>({
+  client: null,
+});
+
+interface ZingClientProviderProps {
+  network: SuiNetwork;
+  suiGrpcClient: SuiGrpcClient;
+  suiJsonRpcClient: SuiJsonRpcClient;
+  gasPoolBearerToken: string;
+  children: ReactNode;
+}
+
+export const ZingClientProvider: React.FC<ZingClientProviderProps> = ({
+  network,
+  suiGrpcClient,
+  suiJsonRpcClient,
+  children,
+  gasPoolBearerToken,
+}) => {
+  const client = useMemo(
+    () =>
+      new ZingClient({
+        network,
+        suiGrpcClient,
+        suiJsonRpcClient,
+        gasPoolBearerToken,
+      }),
+    [network, suiGrpcClient, suiJsonRpcClient, gasPoolBearerToken],
+  );
+
+  return (
+    <ZingClientContext.Provider value={{ client }}>
+      {children}
+    </ZingClientContext.Provider>
+  );
+};
+export const useZingClient = (): ZingClient => {
+  const context = useContext(ZingClientContext);
+  if (!context.client) {
+    throw new Error("useZingClient must be used within a ZingClientProvider");
+  }
+  return context.client;
+};

package/src/config/common.ts

@@ -0,0 +1,82 @@
+export const AUTH_PROVIDDERS = ["Google"] as const;
+export type AuthProvider = (typeof AUTH_PROVIDDERS)[number];
+
+export const PLATFORMS = ["twitter"] as const;
+export type PlatformType = (typeof PLATFORMS)[number];
+
+export const WORKS = ["article"] as const;
+export type WorkType = (typeof WORKS)[number];
+
+export const COIN_SYMBOLS = ["USDC"] as const;
+export type CoinSymbol = (typeof COIN_SYMBOLS)[number];
+
+export const AUTH_PROVIDER_ICON_PATH: Record<AuthProvider, string> = {
+  Google: "icons/google.svg",
+};
+
+export const WALRUS_UPLOAD_FLOW_STAGES = [
+  "encode",
+  "register_blob",
+  "upload",
+  "certify_blob",
+  "publish",
+] as const;
+export type WalrusUploadFlowStage = (typeof WALRUS_UPLOAD_FLOW_STAGES)[number];
+
+export const COIN_DECIMALS: Record<CoinSymbol, number> = {
+  USDC: 6,
+};
+
+export type ProviderInfo = {
+  providerHash: string;
+  name: string;
+  icon: string;
+};
+export const PLATFORM_PROVIDER_INFO: Record<PlatformType, ProviderInfo> = {
+  twitter: {
+    name: "Twitter",
+    icon: "/icons/twitter.svg",
+    providerHash:
+      "0x168c2d4c2c7fd8c0eb21d4cd9aa634a716b61186b1f61e7ab78cd0dbff34fb04",
+  },
+  // instagram: {
+  //   name: 'Instagram',
+  //   icon: 'popup/icons/instagram.svg',
+  //   providerHash: '',
+  // },
+  // medium: {
+  //   name: 'Medium',
+  //   icon: 'popup/icons/medium.svg',
+  //   providerHash: '',
+  // },
+  // substack: {
+  //   name: 'Substack',
+  //   icon: 'popup/icons/substack.svg',
+  //   providerHash: '',
+  // },
+};
+export const PLATFORMS_HOSTNAME: Record<PlatformType, string> = {
+  twitter: "https://x.com",
+  // medium: 'https://medium.com',
+  // substack: 'https://substack.com',
+  // instagram: 'https://www.instagram.com',
+};
+export const LEVEL_FEATURES: Record<
+  number,
+  { name: string; features: string[] }
+> = {
+  0: { name: "Supporter", features: ["Basic Support", "Standard Features"] },
+  1: {
+    name: "Premium",
+    features: ["Priority Support", "Advanced Features", "Analytics"],
+  },
+  2: {
+    name: "VIP",
+    features: [
+      "24/7 Support",
+      "All Features",
+      "Custom Integration",
+      "White Label",
+    ],
+  },
+};

package/src/config/index.ts

@@ -0,0 +1,45 @@
+import {
+  mainnetZingConfig,
+  mainnetWalrusConfig,
+  mainnetSealConfig,
+  mainnetCoinConfig,
+} from "./mainnet.js";
+import {
+  testnetZingConfig,
+  testnetWalrusConfig,
+  testnetSealConfig,
+  testnetCoinConfig,
+} from "./testnet.js";
+import type { Config } from "./types.js";
+import type { SuiNetwork } from "../types.js";
+
+const configs: Record<string, Config> = {
+  mainnet: {
+    zing: mainnetZingConfig,
+    walrus: mainnetWalrusConfig,
+    seal: mainnetSealConfig,
+    coins: mainnetCoinConfig,
+  },
+  testnet: {
+    zing: testnetZingConfig,
+    walrus: testnetWalrusConfig,
+    seal: testnetSealConfig,
+    coins: testnetCoinConfig,
+  },
+};
+
+// TBD: removeed
+export const PROJECT_URL_OBJECT = {
+  url: "https://x.com/ZingonSui",
+} as const;
+
+export function getConfig(network: SuiNetwork = "testnet"): Config {
+  const cfg = configs[network];
+  if (!cfg) {
+    throw new Error(`Unknown Zing network config: ${network}`);
+  }
+  return cfg;
+}
+
+export type * from "./types.js";
+export * from "./common.js";

package/src/config/mainnet.ts

@@ -0,0 +1,109 @@
+import type { CoinSymbol } from "./common.js";
+import type { SealConfig, WalrusConfig, ZingConfig } from "./types.js";
+
+// zing
+export const mainnetZingConfig: ZingConfig = {
+  ZING_FRAMEWORK_PACKAGE_ADDRESS:
+    "0x58c2589e21157bac347513cb4c392ffa34af0e1a630f5a77c0ee92f141057d01",
+  ZING_IDENTITY_PACKAGE_ADDRESS:
+    "0x4a22da297adc51ec5ed6e1f4fc884a45a50d8299b8c3deb9d056392210ce951d",
+  ZING_STUDIO_PACKAGE_ADDRESS:
+    "0x3db3853f032b5b403e35a7d863fb630359c5bec238990f52a8c33c6ac1f5222f",
+  ZING_STUDIO_V0_PACKAGE_ADDRESS:
+    "0xf245105e9896942a02614e4dbbb6c6636452879d58b1e12db1e0364c0d1532a7",
+  ZING_TREASURY_SHARED_OBJECT_REF: {
+    objectId:
+      "0x30f0dc6c1ad6bdf944ed303e9c966af60a3bbbef1b5b9ae3f23de1d44b02f5b6",
+    initialSharedVersion: 661729837,
+    mutable: true,
+  },
+  ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF: {
+    objectId:
+      "0xd511beaa68a5647cdc193b753f3658e8e33bc87ec603857c3d6d315562f0e470",
+    initialSharedVersion: 661729843,
+    mutable: true,
+  },
+  PROOF_COMMITMENT_TYPE:
+    "0xd666d3234eb46551273014f5616ed2575e709a861dd3812613d59104a4cb7344::reclaim::ProofCommitment",
+  IDENTITY_PLATFORMS: {
+    twitter: {
+      PLATFORM_UPDATE_PROOF_TARGET:
+        "0x910fd7e88647ea9369ab269fa5629f0efd815dfa5a7b7ef2355ffee13852413b::twitter::update_with_twitter_proof",
+      PLATFORM_TYPE:
+        "0x910fd7e88647ea9369ab269fa5629f0efd815dfa5a7b7ef2355ffee13852413b::twitter::Twitter",
+      RECLAIM_MANAGER_SHARED_OBJECT_REF: {
+        objectId:
+          "0xe8849f48412d3b7220902fd56b7f128f324ffb27615bf57e83c638f523aa10e6",
+        initialSharedVersion: 662715429,
+        mutable: true,
+      },
+      IDENTITY_MANAGER_SHARED_OBJECT_REF: {
+        objectId:
+          "0xff54f2a3bfc4daedbbc7ecbb1b0985e8311c95fd847f070825882e7e083af5f1",
+        initialSharedVersion: 662715429,
+        mutable: true,
+      },
+      IDENTITY_MANAGER_IDENTIFIER_INFO_DF_ID:
+        "0xcbe996d13835c0fcc9a0a015098546997ae9ff58dd075389bfe764d43bb46c2e",
+      IDENTITY_MANAGER_ADDRESS_TO_IDENTIFIER_DF_ID:
+        "0x20ba08956972f73a956b288dde1659f9ad6059256205beb20bc3fa2cc0377ac2",
+    },
+  },
+  ZING_STUDIO_CONFIG_SHARED_OBJECT_REF: {
+    objectId:
+      "0x9fe332fc68cb2a736a9643dc4f06089c7c4894396db0fb47895d216599ee5c00",
+    initialSharedVersion: 663114127,
+    mutable: true,
+  },
+  ZING_STORAGE_TREASURY_SHARED_OBJECT_REF: {
+    objectId:
+      "0xd80e520d304a43b21c3d2dba2c89463819c2ef9b779c89d15e19b425b385fe74",
+    initialSharedVersion: 663114127,
+    mutable: true,
+  },
+  ZING_WORKS_TYPE: {
+    article:
+      "0xf245105e9896942a02614e4dbbb6c6636452879d58b1e12db1e0364c0d1532a7::article::Article",
+  },
+  EVENT_TYPES: {
+    publishArticleEvent:
+      "0xf245105e9896942a02614e4dbbb6c6636452879d58b1e12db1e0364c0d1532a7::article::PublishArticle",
+  },
+};
+
+// walrus
+export const mainnetWalrusConfig: WalrusConfig = {
+  WALRUS_PACKAGE:
+    "0xfa65cb2d62f4d39e60346fb7d501c12538ca2bbc646eaa37ece2aec5f897814e",
+  WAL_STAKING_INNER_FIELD:
+    "0x16f1f9fcdf5a746da423d1ad055d88f88b24a9272ca8afb4c0dcf074ae6c730a",
+  WALRUS_SYSTEM_SHARED_OBJECT_REF: {
+    objectId:
+      "0x2134d52768ea07e8c43570ef975eb3e4c27a39fa6396bef985b5abc58d03ddd2",
+    initialSharedVersion: 317862159,
+    mutable: true, // mutable when register_blob
+  },
+  WALRUS_AGGREGATORS: ["https://aggregator.suicore.com"],
+  WALRUS_UPLOAD_RELAY_BASE_URL:
+    "https://walrus-upload-relay-production-73a4.up.railway.app",
+  EVENT_TYPES: {
+    blobRegistered:
+      "0xfdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events::BlobRegistered",
+  },
+};
+
+// coins
+export const mainnetCoinConfig: Record<CoinSymbol, string> = {
+  USDC: "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC",
+};
+
+// seal
+export const mainnetSealConfig: SealConfig = {
+  serverConfigs: [
+    {
+      objectId:
+        "0xe0eb52eba9261b96e895bbb4deca10dcd64fbc626a1133017adcd5131353fd10",
+      weight: 1,
+    },
+  ],
+};

package/src/config/testnet.ts

@@ -0,0 +1,111 @@
+import type { CoinSymbol } from "./common.js";
+import type { SealConfig, WalrusConfig, ZingConfig } from "./types.js";
+
+export const testnetZingConfig: ZingConfig = {
+  ZING_FRAMEWORK_PACKAGE_ADDRESS:
+    "0xd851eb5b907b60aa5fd958dd74044d809c49ee60001cad621726f03ea138f943",
+  ZING_IDENTITY_PACKAGE_ADDRESS:
+    "0xaaf27a90890ac1efface4fbb22597e95829cbe6cbb771df02f0d2cc93f067c70",
+  ZING_STUDIO_PACKAGE_ADDRESS:
+    "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa",
+  ZING_STUDIO_V0_PACKAGE_ADDRESS:
+    "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa",
+  ZING_TREASURY_SHARED_OBJECT_REF: {
+    objectId:
+      "0xca56bc3982525decbd4b025d3d4ae4de07259d6efc187577bfc3ab212e20574f",
+    initialSharedVersion: 645292716,
+    mutable: true,
+  },
+  ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF: {
+    objectId:
+      "0xde2eb80aa01db47e65b705c80af931ccb1d56a8a6a06403e205fa8fb1ad4a02e",
+    initialSharedVersion: 645292717,
+    mutable: false,
+  },
+  PROOF_COMMITMENT_TYPE:
+    "0xaaf27a90890ac1efface4fbb22597e95829cbe6cbb771df02f0d2cc93f067c70::reclaim::ProofCommitment",
+  IDENTITY_PLATFORMS: {
+    twitter: {
+      PLATFORM_UPDATE_PROOF_TARGET:
+        "0xa0d84dc088ba37e3108e69458c4dc0d0f836479f384fbe1fe98c737d27945c3e::twitter::update_with_twitter_proof",
+      PLATFORM_TYPE:
+        "0xa0d84dc088ba37e3108e69458c4dc0d0f836479f384fbe1fe98c737d27945c3e::twitter::Twitter",
+      RECLAIM_MANAGER_SHARED_OBJECT_REF: {
+        objectId:
+          "0x3d3c56359728f12f8b54e9e2f5d5861a168f7d75675b83afc7f8b9cce289bfc1",
+        initialSharedVersion: 663897156,
+        mutable: true,
+      },
+      IDENTITY_MANAGER_SHARED_OBJECT_REF: {
+        objectId:
+          "0x44e9171b465f9bbad19864c06cec7ad24d3e830198fe10d9acc84f4e31ad59f6",
+        initialSharedVersion: 663897156,
+        mutable: true,
+      },
+      IDENTITY_MANAGER_IDENTIFIER_INFO_DF_ID:
+        "0x69ff6f5d7e4a64d177c24ae9882e732402065eb9668f41f9337b56fea39bd46d",
+      IDENTITY_MANAGER_ADDRESS_TO_IDENTIFIER_DF_ID:
+        "0x1073c13dfed532938cd978adfcb0b14a165350762392e0bb3137f493112d0520",
+    },
+  },
+  ZING_STUDIO_CONFIG_SHARED_OBJECT_REF: {
+    objectId:
+      "0x4257dc4f3a3fe73e5f8d8c86c2233210876c35dc9b369f72d6aab0521733e57e",
+    initialSharedVersion: 723767900,
+    mutable: false,
+  },
+  ZING_STORAGE_TREASURY_SHARED_OBJECT_REF: {
+    objectId:
+      "0xde26730698493f851a7d9cd4d49b5b56f6781d902d3a63e24aa1f25820924cc8",
+    initialSharedVersion: 723767900,
+    mutable: true,
+  },
+  ZING_WORKS_TYPE: {
+    article:
+      "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa::article::Article",
+  },
+  EVENT_TYPES: {
+    publishArticleEvent:
+      "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa::article::PublishArticleEvent",
+  },
+};
+
+export const testnetWalrusConfig: WalrusConfig = {
+  WALRUS_PACKAGE:
+    "0xa998b8719ca1c0a6dc4e24a859bbb39f5477417f71885fbf2967a6510f699144",
+  WAL_STAKING_INNER_FIELD:
+    "0x93429364cd0447556847e7e96f15c20411e9cc9769c0877e5b6e99732a73a006",
+  WALRUS_SYSTEM_SHARED_OBJECT_REF: {
+    objectId:
+      "0x6c2547cbbc38025cf3adac45f63cb0a8d12ecf777cdc75a4971612bf97fdf6af",
+    initialSharedVersion: 400185623,
+    mutable: true, // mutable when register_blob
+  },
+  WALRUS_AGGREGATORS: ["https://aggregator.suicore.com"],
+  WALRUS_UPLOAD_RELAY_BASE_URL:
+    "https://walrus-upload-relay-production-73a4.up.railway.app",
+  EVENT_TYPES: {
+    blobRegistered:
+      "0xd84704c17fc870b8764832c535aa6b11f21a95cd6f5bb38a9b07d2cf42220c66::events::BlobRegistered",
+  },
+};
+
+// coins
+export const testnetCoinConfig: Record<CoinSymbol, string> = {
+  USDC: "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC",
+};
+
+export const testnetSealConfig: SealConfig = {
+  serverConfigs: [
+    {
+      objectId:
+        "0x73d05d62c18d9374e3ea529e8e0ed6161da1a141a94d3f76ae3fe4e99356db75",
+      weight: 1,
+    },
+    {
+      objectId:
+        "0xf5d14a81a982144ae441cd7d64b09027f116a468bd36e7eca494f750591623c8",
+      weight: 1,
+    },
+  ],
+};