@0xslots/sdk 0.9.1 → 0.9.2

package/dist/index.d.ts

@@ -3816,28 +3816,29 @@ type Sdk = ReturnType<typeof getSdk>;
  * Accessible via `client.modules.metadata`.
  *
  * Read: subgraph queries for MetadataSlot entities
- * Write: `updateMetadata(slot, uri)` on the MetadataModule contract
- * RPC read: `tokenURI(slot)` on the MetadataModule contract
+ * Write: `updateMetadata(moduleAddress, slot, uri)` on the MetadataModule contract
+ * RPC read: `tokenURI(moduleAddress, slot)` on the MetadataModule contract
  */
 declare class MetadataModuleClient {
     private readonly sdk;
-    private readonly chainId;
     private readonly _publicClient?;
     private readonly _walletClient?;
-    private readonly _moduleAddress?;
     constructor(opts: {
         sdk: ReturnType<typeof getSdk>;
-        chainId: number;
         publicClient?: PublicClient;
         walletClient?: WalletClient;
-        moduleAddress?: Address;
     });
-    private get moduleAddress();
     private get wallet();
     private get account();
     private get chain();
     private get publicClient();
     private query;
+    /**
+     * Verify that a given address is a MetadataModule by calling `name()` on-chain.
+     * @param moduleAddress - The module contract address to verify
+     * @throws SlotsError if the contract doesn't return the expected name
+     */
+    private verifyModule;
     /** Get all slots with metadata, ordered by most recently updated. */
     getSlots(...args: Parameters<ReturnType<typeof getSdk>["GetMetadataSlots"]>): Promise<GetMetadataSlotsQuery>;
     /** Get a single metadata slot by slot address. */
@@ -3846,17 +3847,21 @@ declare class MetadataModuleClient {
     getSlotsByRecipient(...args: Parameters<ReturnType<typeof getSdk>["GetMetadataSlotsByRecipient"]>): Promise<GetMetadataSlotsByRecipientQuery>;
     /** Get metadata update history for a slot. */
     getUpdateHistory(...args: Parameters<ReturnType<typeof getSdk>["GetMetadataUpdatedEvents"]>): Promise<GetMetadataUpdatedEventsQuery>;
-    /** Read the current URI for a slot directly from chain (bypasses subgraph). */
-    getURI(slot: Address): Promise<string>;
+    /**
+     * Read the current URI for a slot directly from chain (bypasses subgraph).
+     * @param moduleAddress - The MetadataModule contract address (from the slot's on-chain module field)
+     * @param slot - The slot contract address
+     */
+    getURI(moduleAddress: Address, slot: Address): Promise<string>;
     /**
      * Update the metadata URI for a slot. Only callable by the current occupant.
+     * Verifies on-chain that the address is a MetadataModule before writing.
+     * @param moduleAddress - The MetadataModule contract address (from the slot's on-chain module field)
      * @param slot - The slot contract address
      * @param uri - The new URI (e.g. ipfs://..., https://...)
      * @returns Transaction hash
      */
-    updateMetadata(slot: Address, uri: string): Promise<Hash>;
-    /** Returns the MetadataModule contract address for the configured chain. */
-    getAddress(): Address;
+    updateMetadata(moduleAddress: Address, slot: Address, uri: string): Promise<Hash>;
 }
 
 interface SubgraphMeta {

package/dist/index.js

@@ -1,7 +1,7 @@
 import { gql as gql$1, GraphQLClient } from 'graphql-request';
 import gql from 'graphql-tag';
 import { encodeFunctionData, erc20Abi } from 'viem';
-import { getMetadataModuleAddress, metadataModuleAbi, getSlotsHubAddress, slotAbi, slotFactoryAbi } from '@0xslots/contracts';
+import { metadataModuleAbi, getSlotsHubAddress, slotAbi, slotFactoryAbi } from '@0xslots/contracts';
 
 // src/client.ts
 var AccountFieldsFragmentDoc = gql`
@@ -906,34 +906,33 @@ var SlotsError = class extends Error {
     this.cause = cause;
   }
 };
+var EXPECTED_MODULE_NAME = "MetadataModule";
 var MetadataModuleClient = class {
   constructor(opts) {
     this.sdk = opts.sdk;
-    this.chainId = opts.chainId;
     this._publicClient = opts.publicClient;
     this._walletClient = opts.walletClient;
-    this._moduleAddress = opts.moduleAddress ?? getMetadataModuleAddress(opts.chainId);
-  }
-  get moduleAddress() {
-    if (!this._moduleAddress) throw new SlotsError("metadata", `No MetadataModule deployed on chain ${this.chainId}`);
-    return this._moduleAddress;
   }
   get wallet() {
-    if (!this._walletClient) throw new SlotsError("metadata", "No walletClient provided");
+    if (!this._walletClient)
+      throw new SlotsError("metadata", "No walletClient provided");
     return this._walletClient;
   }
   get account() {
     const account = this.wallet.account;
-    if (!account) throw new SlotsError("metadata", "WalletClient must have an account");
+    if (!account)
+      throw new SlotsError("metadata", "WalletClient must have an account");
     return account.address;
   }
   get chain() {
     const chain = this.wallet.chain;
-    if (!chain) throw new SlotsError("metadata", "WalletClient must have a chain");
+    if (!chain)
+      throw new SlotsError("metadata", "WalletClient must have a chain");
     return chain;
   }
   get publicClient() {
-    if (!this._publicClient) throw new SlotsError("metadata", "No publicClient provided");
+    if (!this._publicClient)
+      throw new SlotsError("metadata", "No publicClient provided");
     return this._publicClient;
   }
   async query(operation, fn) {
@@ -943,34 +942,68 @@ var MetadataModuleClient = class {
       throw new SlotsError(operation, error);
     }
   }
+  /**
+   * Verify that a given address is a MetadataModule by calling `name()` on-chain.
+   * @param moduleAddress - The module contract address to verify
+   * @throws SlotsError if the contract doesn't return the expected name
+   */
+  async verifyModule(moduleAddress) {
+    const name = await this.publicClient.readContract({
+      address: moduleAddress,
+      abi: metadataModuleAbi,
+      functionName: "name"
+    });
+    if (name !== EXPECTED_MODULE_NAME) {
+      throw new SlotsError(
+        "metadata",
+        `Contract at ${moduleAddress} is not a MetadataModule (name: "${name}")`
+      );
+    }
+  }
   // ═══════════════════════════════════════════════════════════════════════════
   // READ — Subgraph
   // ═══════════════════════════════════════════════════════════════════════════
   /** Get all slots with metadata, ordered by most recently updated. */
   getSlots(...args) {
-    return this.query("metadata.getSlots", () => this.sdk.GetMetadataSlots(...args));
+    return this.query(
+      "metadata.getSlots",
+      () => this.sdk.GetMetadataSlots(...args)
+    );
   }
   /** Get a single metadata slot by slot address. */
   getSlot(...args) {
-    return this.query("metadata.getSlot", () => this.sdk.GetMetadataSlot(...args));
+    return this.query(
+      "metadata.getSlot",
+      () => this.sdk.GetMetadataSlot(...args)
+    );
   }
   /** Get all metadata slots for a given recipient. */
   getSlotsByRecipient(...args) {
-    return this.query("metadata.getSlotsByRecipient", () => this.sdk.GetMetadataSlotsByRecipient(...args));
+    return this.query(
+      "metadata.getSlotsByRecipient",
+      () => this.sdk.GetMetadataSlotsByRecipient(...args)
+    );
   }
   /** Get metadata update history for a slot. */
   getUpdateHistory(...args) {
-    return this.query("metadata.getUpdateHistory", () => this.sdk.GetMetadataUpdatedEvents(...args));
+    return this.query(
+      "metadata.getUpdateHistory",
+      () => this.sdk.GetMetadataUpdatedEvents(...args)
+    );
   }
   // ═══════════════════════════════════════════════════════════════════════════
   // READ — RPC
   // ═══════════════════════════════════════════════════════════════════════════
-  /** Read the current URI for a slot directly from chain (bypasses subgraph). */
-  async getURI(slot) {
+  /**
+   * Read the current URI for a slot directly from chain (bypasses subgraph).
+   * @param moduleAddress - The MetadataModule contract address (from the slot's on-chain module field)
+   * @param slot - The slot contract address
+   */
+  async getURI(moduleAddress, slot) {
     return this.query(
       "metadata.getURI",
       () => this.publicClient.readContract({
-        address: this.moduleAddress,
+        address: moduleAddress,
         abi: metadataModuleAbi,
         functionName: "tokenURI",
         args: [slot]
@@ -982,13 +1015,16 @@ var MetadataModuleClient = class {
   // ═══════════════════════════════════════════════════════════════════════════
   /**
    * Update the metadata URI for a slot. Only callable by the current occupant.
+   * Verifies on-chain that the address is a MetadataModule before writing.
+   * @param moduleAddress - The MetadataModule contract address (from the slot's on-chain module field)
    * @param slot - The slot contract address
    * @param uri - The new URI (e.g. ipfs://..., https://...)
    * @returns Transaction hash
    */
-  async updateMetadata(slot, uri) {
+  async updateMetadata(moduleAddress, slot, uri) {
+    await this.verifyModule(moduleAddress);
     return this.wallet.writeContract({
-      address: this.moduleAddress,
+      address: moduleAddress,
       abi: metadataModuleAbi,
       functionName: "updateMetadata",
       args: [slot, uri],
@@ -996,10 +1032,6 @@ var MetadataModuleClient = class {
       chain: this.chain
     });
   }
-  /** Returns the MetadataModule contract address for the configured chain. */
-  getAddress() {
-    return this.moduleAddress;
-  }
 };
 
 // src/client.ts
@@ -1041,7 +1073,6 @@ var SlotsClient = class {
     this.modules = {
       metadata: new MetadataModuleClient({
         sdk: this.sdk,
-        chainId: config.chainId,
         publicClient: config.publicClient,
         walletClient: config.walletClient
       })