@0xslots/sdk 0.9.2 → 0.10.1

package/dist/chunk-VQ5PSOCE.js

@@ -0,0 +1,1628 @@
+import gql from 'graphql-tag';
+import { metadataModuleAbi, getSlotsHubAddress, slotAbi, slotFactoryAbi } from '@0xslots/contracts';
+import { gql as gql$1, GraphQLClient } from 'graphql-request';
+import { encodeFunctionData, erc20Abi } from 'viem';
+
+// src/errors.ts
+var SlotsError = class extends Error {
+  constructor(operation, cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    super(`${operation}: ${msg}`);
+    this.operation = operation;
+    this.name = "SlotsError";
+    this.cause = cause;
+  }
+};
+var AccountFieldsFragmentDoc = gql`
+    fragment AccountFields on Account {
+  id
+  type
+  slotCount
+  occupiedCount
+  slotsAsRecipient {
+    id
+  }
+  slotsAsOccupant {
+    id
+  }
+}
+    `;
+var CurrencyFieldsFragmentDoc = gql`
+    fragment CurrencyFields on Currency {
+  id
+  name
+  symbol
+  decimals
+}
+    `;
+var MetadataSlotFieldsFragmentDoc = gql`
+    fragment MetadataSlotFields on MetadataSlot {
+  id
+  uri
+  rawJson
+  adType
+  updatedBy
+  updateCount
+  createdAt
+  createdTx
+  updatedAt
+  updatedTx
+  slot {
+    id
+    recipient
+    occupant
+    price
+    deposit
+    currency {
+      id
+      symbol
+      decimals
+    }
+  }
+}
+    `;
+var SlotFieldsFragmentDoc = gql`
+    fragment SlotFields on Slot {
+  id
+  recipient
+  recipientAccount {
+    id
+    type
+    slotCount
+    occupiedCount
+  }
+  currency {
+    id
+    name
+    symbol
+    decimals
+  }
+  manager
+  mutableTax
+  mutableModule
+  taxPercentage
+  module {
+    id
+    verified
+    name
+    version
+  }
+  occupant
+  occupantAccount {
+    id
+    type
+    slotCount
+    occupiedCount
+  }
+  price
+  deposit
+  collectedTax
+  totalCollected
+  liquidationBountyBps
+  minDepositSeconds
+  createdAt
+  createdTx
+  updatedAt
+}
+    `;
+var GetAccountDocument = gql`
+    query GetAccount($id: ID!, $block: Block_height) {
+  account(id: $id, block: $block) {
+    ...AccountFields
+  }
+}
+    ${AccountFieldsFragmentDoc}`;
+var GetAccountsDocument = gql`
+    query GetAccounts($first: Int!, $skip: Int, $orderBy: Account_orderBy, $orderDirection: OrderDirection, $where: Account_filter, $block: Block_height) {
+  accounts(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    ...AccountFields
+  }
+}
+    ${AccountFieldsFragmentDoc}`;
+var GetSlotDeployedEventsDocument = gql`
+    query GetSlotDeployedEvents($first: Int!, $skip: Int, $orderBy: SlotDeployedEvent_orderBy, $orderDirection: OrderDirection, $where: SlotDeployedEvent_filter, $block: Block_height) {
+  slotDeployedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    recipient
+    currency {
+      ...CurrencyFields
+    }
+    manager
+    mutableTax
+    mutableModule
+    taxPercentage
+    module
+    liquidationBountyBps
+    minDepositSeconds
+    deployer
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetRecentEventsDocument = gql`
+    query GetRecentEvents($first: Int!, $skip: Int) {
+  slotDeployedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    recipient
+    currency {
+      ...CurrencyFields
+    }
+    deployer
+    timestamp
+    tx
+  }
+  boughtEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    buyer
+    previousOccupant
+    price
+    selfAssessedPrice
+    deposit
+    timestamp
+    tx
+  }
+  releasedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    refund
+    timestamp
+    tx
+  }
+  liquidatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    liquidator
+    occupant
+    bounty
+    timestamp
+    tx
+  }
+  priceUpdatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    oldPrice
+    newPrice
+    timestamp
+    tx
+  }
+  depositedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    depositor
+    amount
+    timestamp
+    tx
+  }
+  withdrawnEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    amount
+    timestamp
+    tx
+  }
+  taxCollectedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    recipient
+    amount
+    timestamp
+    tx
+  }
+  taxUpdateProposedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    newPercentage
+    timestamp
+    tx
+  }
+  moduleUpdateProposedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    newModule
+    timestamp
+    tx
+  }
+  pendingUpdateCancelledEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    timestamp
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetBoughtEventsDocument = gql`
+    query GetBoughtEvents($first: Int!, $skip: Int, $orderBy: BoughtEvent_orderBy, $orderDirection: OrderDirection, $where: BoughtEvent_filter, $block: Block_height) {
+  boughtEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    buyer
+    previousOccupant
+    price
+    deposit
+    selfAssessedPrice
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetReleasedEventsDocument = gql`
+    query GetReleasedEvents($first: Int!, $skip: Int, $orderBy: ReleasedEvent_orderBy, $orderDirection: OrderDirection, $where: ReleasedEvent_filter, $block: Block_height) {
+  releasedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    refund
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetLiquidatedEventsDocument = gql`
+    query GetLiquidatedEvents($first: Int!, $skip: Int, $orderBy: LiquidatedEvent_orderBy, $orderDirection: OrderDirection, $where: LiquidatedEvent_filter, $block: Block_height) {
+  liquidatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    liquidator
+    occupant
+    bounty
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetSettledEventsDocument = gql`
+    query GetSettledEvents($first: Int!, $skip: Int, $orderBy: SettledEvent_orderBy, $orderDirection: OrderDirection, $where: SettledEvent_filter, $block: Block_height) {
+  settledEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    taxOwed
+    taxPaid
+    depositRemaining
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetTaxCollectedEventsDocument = gql`
+    query GetTaxCollectedEvents($first: Int!, $skip: Int, $orderBy: TaxCollectedEvent_orderBy, $orderDirection: OrderDirection, $where: TaxCollectedEvent_filter, $block: Block_height) {
+  taxCollectedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    recipient
+    amount
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetDepositedEventsDocument = gql`
+    query GetDepositedEvents($first: Int!, $skip: Int, $orderBy: DepositedEvent_orderBy, $orderDirection: OrderDirection, $where: DepositedEvent_filter, $block: Block_height) {
+  depositedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    depositor
+    amount
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetWithdrawnEventsDocument = gql`
+    query GetWithdrawnEvents($first: Int!, $skip: Int, $orderBy: WithdrawnEvent_orderBy, $orderDirection: OrderDirection, $where: WithdrawnEvent_filter, $block: Block_height) {
+  withdrawnEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    amount
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetPriceUpdatedEventsDocument = gql`
+    query GetPriceUpdatedEvents($first: Int!, $skip: Int, $orderBy: PriceUpdatedEvent_orderBy, $orderDirection: OrderDirection, $where: PriceUpdatedEvent_filter, $block: Block_height) {
+  priceUpdatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    id
+    slot {
+      id
+    }
+    currency {
+      ...CurrencyFields
+    }
+    oldPrice
+    newPrice
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetSlotActivityDocument = gql`
+    query GetSlotActivity($slotId: String!, $first: Int!, $skip: Int) {
+  boughtEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    buyer
+    previousOccupant
+    price
+    selfAssessedPrice
+    deposit
+    timestamp
+    tx
+  }
+  releasedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    refund
+    timestamp
+    tx
+  }
+  liquidatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    liquidator
+    occupant
+    bounty
+    timestamp
+    tx
+  }
+  priceUpdatedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    oldPrice
+    newPrice
+    timestamp
+    tx
+  }
+  depositedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    depositor
+    amount
+    timestamp
+    tx
+  }
+  withdrawnEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    occupant
+    amount
+    timestamp
+    tx
+  }
+  taxCollectedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    currency {
+      ...CurrencyFields
+    }
+    recipient
+    amount
+    timestamp
+    tx
+  }
+  taxUpdateProposedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    newPercentage
+    timestamp
+    tx
+  }
+  moduleUpdateProposedEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    newModule
+    timestamp
+    tx
+  }
+  pendingUpdateCancelledEvents(
+    first: $first
+    skip: $skip
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    timestamp
+    tx
+  }
+}
+    ${CurrencyFieldsFragmentDoc}`;
+var GetFactoryDocument = gql`
+    query GetFactory {
+  factories(first: 1) {
+    id
+    slotCount
+  }
+}
+    `;
+var GetModulesDocument = gql`
+    query GetModules($first: Int!) {
+  modules(first: $first) {
+    id
+    verified
+    name
+    version
+  }
+}
+    `;
+var GetMetadataSlotsDocument = gql`
+    query GetMetadataSlots($first: Int = 100, $skip: Int = 0, $orderBy: MetadataSlot_orderBy = updatedAt, $orderDirection: OrderDirection = desc) {
+  metadataSlots(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+  ) {
+    ...MetadataSlotFields
+  }
+}
+    ${MetadataSlotFieldsFragmentDoc}`;
+var GetMetadataSlotDocument = gql`
+    query GetMetadataSlot($id: ID!) {
+  metadataSlot(id: $id) {
+    ...MetadataSlotFields
+  }
+}
+    ${MetadataSlotFieldsFragmentDoc}`;
+var GetMetadataSlotsByRecipientDocument = gql`
+    query GetMetadataSlotsByRecipient($recipient: Bytes!, $first: Int = 100) {
+  metadataSlots(
+    first: $first
+    where: {slot_: {recipient: $recipient}}
+    orderBy: updatedAt
+    orderDirection: desc
+  ) {
+    ...MetadataSlotFields
+  }
+}
+    ${MetadataSlotFieldsFragmentDoc}`;
+var GetMetadataUpdatedEventsDocument = gql`
+    query GetMetadataUpdatedEvents($slot: String, $first: Int = 50, $orderBy: MetadataUpdatedEvent_orderBy = timestamp, $orderDirection: OrderDirection = desc) {
+  metadataUpdatedEvents(
+    first: $first
+    where: {slot: $slot}
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+  ) {
+    id
+    slot {
+      id
+    }
+    author {
+      id
+      type
+    }
+    uri
+    rawJson
+    adType
+    timestamp
+    blockNumber
+    tx
+  }
+}
+    `;
+var GetSlotsDocument = gql`
+    query GetSlots($first: Int!, $skip: Int, $orderBy: Slot_orderBy, $orderDirection: OrderDirection, $where: Slot_filter, $block: Block_height) {
+  slots(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+    block: $block
+  ) {
+    ...SlotFields
+  }
+}
+    ${SlotFieldsFragmentDoc}`;
+var GetSlotDocument = gql`
+    query GetSlot($id: ID!, $block: Block_height) {
+  slot(id: $id, block: $block) {
+    ...SlotFields
+  }
+}
+    ${SlotFieldsFragmentDoc}`;
+var GetSlotsByRecipientDocument = gql`
+    query GetSlotsByRecipient($recipient: Bytes!, $first: Int!, $skip: Int, $orderBy: Slot_orderBy, $orderDirection: OrderDirection, $block: Block_height) {
+  slots(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: {recipient: $recipient}
+    block: $block
+  ) {
+    ...SlotFields
+  }
+}
+    ${SlotFieldsFragmentDoc}`;
+var GetSlotsByOccupantDocument = gql`
+    query GetSlotsByOccupant($occupant: Bytes!, $first: Int!, $skip: Int, $orderBy: Slot_orderBy, $orderDirection: OrderDirection, $block: Block_height) {
+  slots(
+    first: $first
+    skip: $skip
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: {occupant: $occupant}
+    block: $block
+  ) {
+    ...SlotFields
+  }
+}
+    ${SlotFieldsFragmentDoc}`;
+var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
+function getSdk(client, withWrapper = defaultWrapper) {
+  return {
+    GetAccount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAccountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAccount", "query", variables);
+    },
+    GetAccounts(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAccountsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAccounts", "query", variables);
+    },
+    GetSlotDeployedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotDeployedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotDeployedEvents", "query", variables);
+    },
+    GetRecentEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetRecentEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetRecentEvents", "query", variables);
+    },
+    GetBoughtEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBoughtEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetBoughtEvents", "query", variables);
+    },
+    GetReleasedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetReleasedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetReleasedEvents", "query", variables);
+    },
+    GetLiquidatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLiquidatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLiquidatedEvents", "query", variables);
+    },
+    GetSettledEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSettledEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSettledEvents", "query", variables);
+    },
+    GetTaxCollectedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTaxCollectedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetTaxCollectedEvents", "query", variables);
+    },
+    GetDepositedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetDepositedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetDepositedEvents", "query", variables);
+    },
+    GetWithdrawnEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetWithdrawnEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetWithdrawnEvents", "query", variables);
+    },
+    GetPriceUpdatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPriceUpdatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetPriceUpdatedEvents", "query", variables);
+    },
+    GetSlotActivity(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotActivityDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotActivity", "query", variables);
+    },
+    GetFactory(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetFactoryDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetFactory", "query", variables);
+    },
+    GetModules(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetModulesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetModules", "query", variables);
+    },
+    GetMetadataSlots(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetMetadataSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetMetadataSlots", "query", variables);
+    },
+    GetMetadataSlot(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetMetadataSlotDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetMetadataSlot", "query", variables);
+    },
+    GetMetadataSlotsByRecipient(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetMetadataSlotsByRecipientDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetMetadataSlotsByRecipient", "query", variables);
+    },
+    GetMetadataUpdatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetMetadataUpdatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetMetadataUpdatedEvents", "query", variables);
+    },
+    GetSlots(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlots", "query", variables);
+    },
+    GetSlot(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlot", "query", variables);
+    },
+    GetSlotsByRecipient(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotsByRecipientDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotsByRecipient", "query", variables);
+    },
+    GetSlotsByOccupant(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotsByOccupantDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotsByOccupant", "query", variables);
+    }
+  };
+}
+var EXPECTED_MODULE_NAME = "MetadataModule";
+var MetadataModuleClient = class {
+  constructor(opts) {
+    this.sdk = opts.sdk;
+    this._publicClient = opts.publicClient;
+    this._walletClient = opts.walletClient;
+  }
+  get wallet() {
+    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");
+    return account.address;
+  }
+  get chain() {
+    const chain = this.wallet.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");
+    return this._publicClient;
+  }
+  async query(operation, fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      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)
+    );
+  }
+  /** Get a single metadata slot by slot address. */
+  getSlot(...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)
+    );
+  }
+  /** Get metadata update history for a slot. */
+  getUpdateHistory(...args) {
+    return this.query(
+      "metadata.getUpdateHistory",
+      () => this.sdk.GetMetadataUpdatedEvents(...args)
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // READ — RPC
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * 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: moduleAddress,
+        abi: metadataModuleAbi,
+        functionName: "tokenURI",
+        args: [slot]
+      })
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * 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(moduleAddress, slot, uri) {
+    await this.verifyModule(moduleAddress);
+    return this.wallet.writeContract({
+      address: moduleAddress,
+      abi: metadataModuleAbi,
+      functionName: "updateMetadata",
+      args: [slot, uri],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+};
+var META_QUERY = gql$1`
+  query GetMeta {
+    _meta {
+      block {
+        number
+        hash
+        timestamp
+      }
+      hasIndexingErrors
+    }
+  }
+`;
+var SlotsChain = /* @__PURE__ */ ((SlotsChain2) => {
+  SlotsChain2[SlotsChain2["BASE"] = 8453] = "BASE";
+  SlotsChain2[SlotsChain2["BASE_SEPOLIA"] = 84532] = "BASE_SEPOLIA";
+  return SlotsChain2;
+})(SlotsChain || {});
+var SUBGRAPH_URLS = {
+  [84532 /* BASE_SEPOLIA */]: "https://gateway.thegraph.com/api/subgraphs/id/Z361DLoMdPh9WAopH7shJP8WoXYAB9XeKrLUCTYjdZR",
+  [8453 /* BASE */]: "https://gateway.thegraph.com/api/subgraphs/id/4sZrdv1SFzN4KzE9jiWDRuUyM4CnCrmvQ54Rv1s65qUq"
+};
+var SlotsClient = class {
+  constructor(config) {
+    this.chainId = config.chainId;
+    this._publicClient = config.publicClient;
+    this.walletClient = config.walletClient;
+    this._factory = config.factoryAddress ?? getSlotsHubAddress(config.chainId);
+    const url = config.subgraphUrl || SUBGRAPH_URLS[config.chainId];
+    if (!url) throw new Error(`No subgraph URL for chain ${config.chainId}`);
+    const headers = { ...config.headers };
+    if (config.subgraphApiKey) {
+      headers["Authorization"] = `Bearer ${config.subgraphApiKey}`;
+    }
+    this.gqlClient = new GraphQLClient(url, { headers });
+    this.sdk = getSdk(this.gqlClient);
+    this.modules = {
+      metadata: new MetadataModuleClient({
+        sdk: this.sdk,
+        publicClient: config.publicClient,
+        walletClient: config.walletClient
+      })
+    };
+  }
+  // ─── Accessors ──────────────────────────────────────────────────────────────
+  /** Returns the chain ID this client was configured for. */
+  getChainId() {
+    return this.chainId;
+  }
+  /** Returns the underlying GraphQL client (for advanced usage). */
+  getClient() {
+    return this.gqlClient;
+  }
+  /** Returns the generated GraphQL SDK (for queries not wrapped by this client). */
+  getSdk() {
+    return this.sdk;
+  }
+  get publicClient() {
+    if (!this._publicClient) throw new Error("No publicClient provided");
+    return this._publicClient;
+  }
+  get factory() {
+    if (!this._factory) throw new Error("No factoryAddress provided");
+    return this._factory;
+  }
+  get wallet() {
+    if (!this.walletClient) throw new Error("No walletClient provided");
+    return this.walletClient;
+  }
+  get account() {
+    const account = this.wallet.account;
+    if (!account) throw new Error("WalletClient must have an account");
+    return account.address;
+  }
+  get chain() {
+    const chain = this.wallet.chain;
+    if (!chain) throw new Error("WalletClient must have a chain");
+    return chain;
+  }
+  // ─── Helpers ────────────────────────────────────────────────────────────────
+  assertPositive(value, name) {
+    if (value <= 0n) throw new SlotsError(name, `${name} must be > 0`);
+  }
+  async query(operation, fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      throw new SlotsError(operation, error);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // READ — Subgraph Queries
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Slot queries
+  /** Fetch a paginated list of slots. */
+  getSlots(...args) {
+    return this.query("getSlots", () => this.sdk.GetSlots(...args));
+  }
+  /** Fetch a single slot by its address. */
+  getSlot(...args) {
+    return this.query("getSlot", () => this.sdk.GetSlot(...args));
+  }
+  /** Fetch all slots owned by a given recipient address. */
+  getSlotsByRecipient(...args) {
+    return this.query(
+      "getSlotsByRecipient",
+      () => this.sdk.GetSlotsByRecipient(...args)
+    );
+  }
+  /** Fetch all slots currently occupied by a given address. */
+  getSlotsByOccupant(...args) {
+    return this.query(
+      "getSlotsByOccupant",
+      () => this.sdk.GetSlotsByOccupant(...args)
+    );
+  }
+  // Factory queries
+  /** Fetch factory configuration. */
+  getFactory() {
+    return this.query("getFactory", () => this.sdk.GetFactory());
+  }
+  /** Fetch registered modules. */
+  getModules(...args) {
+    return this.query("getModules", () => this.sdk.GetModules(...args));
+  }
+  // Event queries
+  /** Fetch slot deployed events with optional filters. */
+  getSlotDeployedEvents(...args) {
+    return this.query(
+      "getSlotDeployedEvents",
+      () => this.sdk.GetSlotDeployedEvents(...args)
+    );
+  }
+  /** Fetch bought events with optional filters. */
+  getBoughtEvents(...args) {
+    return this.query(
+      "getBoughtEvents",
+      () => this.sdk.GetBoughtEvents(...args)
+    );
+  }
+  /** Fetch settled events with optional filters. */
+  getSettledEvents(...args) {
+    return this.query(
+      "getSettledEvents",
+      () => this.sdk.GetSettledEvents(...args)
+    );
+  }
+  /** Fetch tax-collected events with optional filters. */
+  getTaxCollectedEvents(...args) {
+    return this.query(
+      "getTaxCollectedEvents",
+      () => this.sdk.GetTaxCollectedEvents(...args)
+    );
+  }
+  /** Fetch all activity for a specific slot (all event types). */
+  getSlotActivity(...args) {
+    return this.query(
+      "getSlotActivity",
+      () => this.sdk.GetSlotActivity(...args)
+    );
+  }
+  /** Fetch the most recent events across all slots. */
+  getRecentEvents(...args) {
+    return this.query(
+      "getRecentEvents",
+      () => this.sdk.GetRecentEvents(...args)
+    );
+  }
+  // Account queries
+  /** Fetch a single account by address. */
+  getAccount(...args) {
+    return this.query("getAccount", () => this.sdk.GetAccount(...args));
+  }
+  /** Fetch a paginated list of accounts. */
+  getAccounts(...args) {
+    return this.query("getAccounts", () => this.sdk.GetAccounts(...args));
+  }
+  // Individual event queries
+  /** Fetch released events with optional filters. */
+  getReleasedEvents(...args) {
+    return this.query(
+      "getReleasedEvents",
+      () => this.sdk.GetReleasedEvents(...args)
+    );
+  }
+  /** Fetch liquidated events with optional filters. */
+  getLiquidatedEvents(...args) {
+    return this.query(
+      "getLiquidatedEvents",
+      () => this.sdk.GetLiquidatedEvents(...args)
+    );
+  }
+  /** Fetch deposited events with optional filters. */
+  getDepositedEvents(...args) {
+    return this.query(
+      "getDepositedEvents",
+      () => this.sdk.GetDepositedEvents(...args)
+    );
+  }
+  /** Fetch withdrawn events with optional filters. */
+  getWithdrawnEvents(...args) {
+    return this.query(
+      "getWithdrawnEvents",
+      () => this.sdk.GetWithdrawnEvents(...args)
+    );
+  }
+  /** Fetch price-updated events with optional filters. */
+  getPriceUpdatedEvents(...args) {
+    return this.query(
+      "getPriceUpdatedEvents",
+      () => this.sdk.GetPriceUpdatedEvents(...args)
+    );
+  }
+  // Meta
+  /** Fetch subgraph indexing metadata (latest block, indexing errors). */
+  getMeta() {
+    return this.query(
+      "getMeta",
+      () => this.gqlClient.request(META_QUERY)
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // READ — On-chain (RPC)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Read full slot info from on-chain (RPC, not subgraph).
+   * @param slot - Slot contract address.
+   * @returns On-chain slot info tuple.
+   * @throws {SlotsError} If the RPC call fails.
+   */
+  getSlotInfo(slot) {
+    return this.query(
+      "getSlotInfo",
+      () => this.publicClient.readContract({
+        address: slot,
+        abi: slotAbi,
+        functionName: "getSlotInfo"
+      })
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Factory Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Deploy a new slot via the factory contract.
+   * @param params - Slot creation parameters (recipient, currency, config, initParams).
+   * @returns Transaction hash.
+   */
+  async createSlot(params) {
+    return this.wallet.writeContract({
+      address: this.factory,
+      abi: slotFactoryAbi,
+      functionName: "createSlot",
+      args: [params.recipient, params.currency, params.config, params.initParams],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Deploy multiple identical slots in a single transaction via the factory contract.
+   * @param params - Slot creation parameters including count.
+   * @returns Transaction hash.
+   */
+  async createSlots(params) {
+    return this.wallet.writeContract({
+      address: this.factory,
+      abi: slotFactoryAbi,
+      functionName: "createSlots",
+      args: [
+        params.recipient,
+        params.currency,
+        params.config,
+        params.initParams,
+        params.count
+      ],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Slot Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Buy a slot (or force-buy an occupied one). Handles ERC-20 approval automatically.
+   * @param params - Buy parameters (slot address, deposit amount, self-assessed price).
+   * @returns Transaction hash.
+   * @throws {SlotsError} If depositAmount or selfAssessedPrice is not positive, or the transaction fails.
+   */
+  async buy(params) {
+    this.assertPositive(params.depositAmount, "depositAmount");
+    this.assertPositive(params.selfAssessedPrice, "selfAssessedPrice");
+    return this.withAllowance(params.slot, params.depositAmount, {
+      to: params.slot,
+      abi: slotAbi,
+      functionName: "buy",
+      args: [params.depositAmount, params.selfAssessedPrice]
+    });
+  }
+  /**
+   * Self-assess a new price for an occupied slot (occupant only).
+   * @param slot - The slot contract address.
+   * @param newPrice - The new self-assessed price (can be 0).
+   * @returns Transaction hash.
+   */
+  async selfAssess(slot, newPrice) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "selfAssess",
+      args: [newPrice],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Top up deposit on a slot (occupant only). Handles ERC-20 approval automatically.
+   * @param slot - The slot contract address.
+   * @param amount - The amount to deposit (must be > 0).
+   * @returns Transaction hash.
+   * @throws {SlotsError} If amount is not positive, or the transaction fails.
+   */
+  async topUp(slot, amount) {
+    this.assertPositive(amount, "amount");
+    return this.withAllowance(slot, amount, {
+      to: slot,
+      abi: slotAbi,
+      functionName: "topUp",
+      args: [amount]
+    });
+  }
+  /**
+   * Withdraw from deposit (occupant only). Cannot go below minimum deposit.
+   * @param slot - The slot contract address.
+   * @param amount - The amount to withdraw (must be > 0).
+   * @returns Transaction hash.
+   * @throws {SlotsError} If amount is not positive, or the transaction fails.
+   */
+  async withdraw(slot, amount) {
+    this.assertPositive(amount, "amount");
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "withdraw",
+      args: [amount],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Release a slot (occupant only). Returns remaining deposit to the occupant.
+   * @param slot - The slot contract address.
+   * @returns Transaction hash.
+   */
+  async release(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "release",
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Collect accumulated tax (permissionless).
+   * @param slot - The slot contract address.
+   * @returns Transaction hash.
+   */
+  async collect(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "collect",
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Liquidate an insolvent slot (permissionless). Caller receives bounty.
+   * @param slot - The slot contract address.
+   * @returns Transaction hash.
+   */
+  async liquidate(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "liquidate",
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Manager Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Propose a tax rate update (manager only, slot must have mutableTax).
+   * @param slot - The slot contract address.
+   * @param newPct - The new tax percentage.
+   * @returns Transaction hash.
+   */
+  async proposeTaxUpdate(slot, newPct) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "proposeTaxUpdate",
+      args: [newPct],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Propose a module update (manager only, slot must have mutableModule).
+   * @param slot - The slot contract address.
+   * @param newModule - The new module contract address.
+   * @returns Transaction hash.
+   */
+  async proposeModuleUpdate(slot, newModule) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "proposeModuleUpdate",
+      args: [newModule],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Cancel pending updates (manager only).
+   * @param slot - The slot contract address.
+   * @returns Transaction hash.
+   */
+  async cancelPendingUpdates(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "cancelPendingUpdates",
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  /**
+   * Set liquidation bounty bps (manager only).
+   * @param slot - The slot contract address.
+   * @param newBps - The new bounty in basis points (0-10000).
+   * @returns Transaction hash.
+   * @throws {SlotsError} If newBps is outside 0-10000, or the transaction fails.
+   */
+  async setLiquidationBounty(slot, newBps) {
+    if (newBps < 0n || newBps > 10000n)
+      throw new SlotsError("setLiquidationBounty", "newBps must be 0-10000");
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "setLiquidationBounty",
+      args: [newBps],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Multicall
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Batch multiple slot calls into one transaction via multicall.
+   * @param slot - The slot contract address.
+   * @param calls - Array of function calls to batch.
+   * @returns Transaction hash.
+   * @throws {SlotsError} If calls array is empty, or the transaction fails.
+   */
+  async multicall(slot, calls) {
+    if (calls.length === 0)
+      throw new SlotsError("multicall", "calls array must not be empty");
+    const data = calls.map(
+      (call) => encodeFunctionData({
+        abi: slotAbi,
+        functionName: call.functionName,
+        args: call.args
+      })
+    );
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "multicall",
+      args: [data],
+      account: this.account,
+      chain: this.chain
+    });
+  }
+  // ─── Internals ──────────────────────────────────────────────────────────────
+  /** Check if wallet supports atomic batch calls (EIP-5792). */
+  async supportsAtomicBatch() {
+    if (this._atomicSupport !== void 0) return this._atomicSupport;
+    try {
+      const capabilities = await this.wallet.getCapabilities?.();
+      if (!capabilities) {
+        this._atomicSupport = false;
+        return false;
+      }
+      const chainId = this.chain.id;
+      const chainCaps = capabilities[chainId] || capabilities[`0x${chainId.toString(16)}`];
+      const atomic = chainCaps?.atomicBatch ?? chainCaps?.atomic;
+      const status = atomic && typeof atomic === "object" && "status" in atomic ? atomic.status : void 0;
+      this._atomicSupport = status === "supported" || status === "ready";
+    } catch {
+      this._atomicSupport = false;
+    }
+    return this._atomicSupport;
+  }
+  /** Poll EIP-5792 getCallsStatus until the batch settles, then return a tx hash. */
+  async pollBatchReceipt(id) {
+    const MAX_ATTEMPTS = 60;
+    const INTERVAL = 1500;
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const result = await this.wallet.getCallsStatus({ id });
+      if (result.status === "success") {
+        const receipts = result.receipts ?? [];
+        return receipts[receipts.length - 1]?.transactionHash ?? id;
+      }
+      if (result.status === "failure") {
+        throw new Error("Batch transaction reverted");
+      }
+      await new Promise((r) => setTimeout(r, INTERVAL));
+    }
+    throw new Error("Batch transaction timed out");
+  }
+  /**
+   * Execute a contract call that needs ERC-20 allowance.
+   * If wallet supports atomic batch (EIP-5792): sends approve + action as one atomic call.
+   * Otherwise: chains approve tx (if needed) then action tx.
+   */
+  async withAllowance(spender, amount, call) {
+    const currency = await this.publicClient.readContract({
+      address: spender,
+      abi: slotAbi,
+      functionName: "currency"
+    });
+    const allowance = await this.publicClient.readContract({
+      address: currency,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [this.account, spender]
+    });
+    const needsApproval = allowance < amount;
+    if (needsApproval && await this.supportsAtomicBatch()) {
+      const approveData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [spender, amount]
+      });
+      const actionData = encodeFunctionData({
+        abi: call.abi,
+        functionName: call.functionName,
+        args: call.args
+      });
+      const id = await this.wallet.sendCalls({
+        account: this.account,
+        chain: this.chain,
+        calls: [
+          { to: currency, data: approveData },
+          { to: call.to, data: actionData }
+        ]
+      });
+      const txHash = await this.pollBatchReceipt(id);
+      return txHash;
+    }
+    if (needsApproval) {
+      const hash = await this.wallet.writeContract({
+        address: currency,
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [spender, amount],
+        account: this.account,
+        chain: this.chain
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+    }
+    return this.wallet.writeContract({
+      address: call.to,
+      abi: call.abi,
+      functionName: call.functionName,
+      args: call.args,
+      account: this.account,
+      chain: this.chain
+    });
+  }
+};
+function createSlotsClient(config) {
+  return new SlotsClient(config);
+}
+
+export { AccountFieldsFragmentDoc, CurrencyFieldsFragmentDoc, GetAccountDocument, GetAccountsDocument, GetBoughtEventsDocument, GetDepositedEventsDocument, GetFactoryDocument, GetLiquidatedEventsDocument, GetMetadataSlotDocument, GetMetadataSlotsByRecipientDocument, GetMetadataSlotsDocument, GetMetadataUpdatedEventsDocument, GetModulesDocument, GetPriceUpdatedEventsDocument, GetRecentEventsDocument, GetReleasedEventsDocument, GetSettledEventsDocument, GetSlotActivityDocument, GetSlotDeployedEventsDocument, GetSlotDocument, GetSlotsByOccupantDocument, GetSlotsByRecipientDocument, GetSlotsDocument, GetTaxCollectedEventsDocument, GetWithdrawnEventsDocument, MetadataModuleClient, MetadataSlotFieldsFragmentDoc, SUBGRAPH_URLS, SlotFieldsFragmentDoc, SlotsChain, SlotsClient, SlotsError, createSlotsClient, getSdk };
+//# sourceMappingURL=chunk-VQ5PSOCE.js.map
+//# sourceMappingURL=chunk-VQ5PSOCE.js.map