@0xslots/sdk 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,327 +1,611 @@
-import { GraphQLClient } from 'graphql-request';
+import { gql as gql$1, GraphQLClient } from 'graphql-request';
 import gql from 'graphql-tag';
+import { encodeFunctionData, erc20Abi } from 'viem';
+import { getSlotsHubAddress, slotAbi, slotFactoryAbi } from '@0xslots/contracts';
 
 // src/client.ts
-var GetSlotPurchasesDocument = gql`
-    query GetSlotPurchases($first: Int = 100, $skip: Int = 0, $orderBy: SlotPurchase_orderBy, $orderDirection: OrderDirection, $where: SlotPurchase_filter) {
-  slotPurchases(
+var AccountFieldsFragmentDoc = gql`
+    fragment AccountFields on Account {
+  id
+  slotCount
+  occupiedCount
+  slotsAsRecipient {
+    id
+  }
+  slotsAsOccupant {
+    id
+  }
+}
+    `;
+var SlotFieldsFragmentDoc = gql`
+    fragment SlotFields on Slot {
+  id
+  recipient
+  recipientAccount {
+    id
+    slotCount
+    occupiedCount
+  }
+  currency
+  currencyName
+  currencySymbol
+  currencyDecimals
+  manager
+  mutableTax
+  mutableModule
+  taxPercentage
+  module {
+    id
+    verified
+    name
+    version
+  }
+  occupant
+  occupantAccount {
+    id
+    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 GetRecentEventsDocument = gql`
+    query GetRecentEvents($first: Int!) {
+  boughtEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
     id
     slot {
       id
-      slotId
-      land {
-        id
-      }
     }
-    newOccupant
+    buyer
     previousOccupant
+    price
+    selfAssessedPrice
+    deposit
+    timestamp
+    tx
+  }
+  releasedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    occupant
+    refund
+    timestamp
+    tx
+  }
+  liquidatedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    liquidator
+    occupant
+    bounty
+    timestamp
+    tx
+  }
+  priceUpdatedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    oldPrice
+    newPrice
+    timestamp
+    tx
+  }
+  depositedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    depositor
+    amount
+    timestamp
+    tx
+  }
+  withdrawnEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    occupant
+    amount
+    timestamp
+    tx
+  }
+  taxCollectedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    recipient
+    amount
+    timestamp
+    tx
+  }
+  taxUpdateProposedEvents(first: $first, orderBy: timestamp, orderDirection: desc) {
+    id
+    slot {
+      id
+    }
+    newPercentage
+    timestamp
+    tx
+  }
+  moduleUpdateProposedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
+    newModule
+    timestamp
+    tx
+  }
+  pendingUpdateCancelledEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+  ) {
+    id
+    slot {
+      id
+    }
     timestamp
-    blockNumber
     tx
   }
 }
     `;
-var GetLandOpenedEventsDocument = gql`
-    query GetLandOpenedEvents($first: Int = 100, $orderBy: LandOpenedEvent_orderBy, $orderDirection: OrderDirection) {
-  landOpenedEvents(
+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
-    land {
+    slot {
       id
     }
-    account
+    buyer
+    previousOccupant
+    price
+    deposit
+    selfAssessedPrice
     timestamp
     blockNumber
     tx
   }
 }
     `;
-var GetSlotCreatedEventsDocument = gql`
-    query GetSlotCreatedEvents($first: Int = 100, $orderBy: SlotCreatedEvent_orderBy, $orderDirection: OrderDirection, $where: SlotCreatedEvent_filter) {
-  slotCreatedEvents(
+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
-      slotId
     }
-    land
-    slotId
-    currency
-    basePrice
-    taxPercentage
+    occupant
+    refund
     timestamp
     blockNumber
     tx
   }
 }
     `;
-var GetPriceUpdatesDocument = gql`
-    query GetPriceUpdates($first: Int = 100, $orderBy: PriceUpdate_orderBy, $orderDirection: OrderDirection, $where: PriceUpdate_filter) {
-  priceUpdates(
+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
-      slotId
     }
-    oldPrice
-    newPrice
+    liquidator
+    occupant
+    bounty
     timestamp
     blockNumber
     tx
   }
 }
     `;
-var GetHubDocument = gql`
-    query GetHub($id: ID!) {
-  hub(id: $id) {
-    id
-    protocolFeeBps
-    protocolFeeRecipient
-    landCreationFee
-    slotExpansionFee
-    defaultCurrency {
+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
-      name
-      symbol
-      decimals
     }
-    defaultSlotCount
-    defaultPrice
-    defaultTaxPercentage
-    defaultMaxTaxPercentage
-    defaultMinTaxUpdatePeriod
-    defaultModule
-    moduleCallGasLimit
-    liquidationBountyBps
-    minDepositSeconds
+    taxOwed
+    taxPaid
+    depositRemaining
+    timestamp
+    blockNumber
+    tx
   }
 }
     `;
-var GetAllowedModulesDocument = gql`
-    query GetAllowedModules($hubId: String!) {
-  modules(where: {hub: $hubId, allowed: true}) {
+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
-    name
-    version
-    allowed
+    slot {
+      id
+    }
+    recipient
+    amount
+    timestamp
+    blockNumber
+    tx
   }
 }
     `;
-var GetAllowedCurrenciesDocument = gql`
-    query GetAllowedCurrencies($hubId: String!) {
-  currencies(where: {hub: $hubId, allowed: true}) {
+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
-    name
-    symbol
-    decimals
+    slot {
+      id
+    }
+    depositor
+    amount
+    timestamp
+    blockNumber
+    tx
   }
 }
     `;
-var GetLandsDocument = gql`
-    query GetLands($first: Int = 100, $skip: Int = 0, $orderBy: Land_orderBy, $orderDirection: OrderDirection) {
-  lands(
+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
-    owner
-    hub {
+    slot {
       id
     }
-    createdAt
-    createdTx
+    occupant
+    amount
+    timestamp
+    blockNumber
+    tx
   }
 }
     `;
-var GetLandDocument = gql`
-    query GetLand($id: ID!) {
-  land(id: $id) {
+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
-    owner
-    hub {
-      id
-    }
-    createdAt
-    createdTx
-    slots {
+    slot {
       id
-      slotId
-      occupant
-      currency
-      price
-      taxPercentage
-      active
     }
+    oldPrice
+    newPrice
+    timestamp
+    blockNumber
+    tx
   }
 }
     `;
-var GetLandsByOwnerDocument = gql`
-    query GetLandsByOwner($owner: Bytes!, $first: Int = 100) {
-  lands(where: {owner: $owner}, first: $first) {
+var GetSlotActivityDocument = gql`
+    query GetSlotActivity($slotId: String!, $first: Int!) {
+  boughtEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    buyer
+    previousOccupant
+    price
+    selfAssessedPrice
+    deposit
+    timestamp
+    tx
+  }
+  releasedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
     id
-    owner
-    createdAt
-    createdTx
+    occupant
+    refund
+    timestamp
+    tx
+  }
+  liquidatedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    liquidator
+    occupant
+    bounty
+    timestamp
+    tx
+  }
+  priceUpdatedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    oldPrice
+    newPrice
+    timestamp
+    tx
+  }
+  depositedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    depositor
+    amount
+    timestamp
+    tx
+  }
+  withdrawnEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    occupant
+    amount
+    timestamp
+    tx
+  }
+  taxCollectedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    recipient
+    amount
+    timestamp
+    tx
+  }
+  taxUpdateProposedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    newPercentage
+    timestamp
+    tx
+  }
+  moduleUpdateProposedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    newModule
+    timestamp
+    tx
+  }
+  pendingUpdateCancelledEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
+    id
+    timestamp
+    tx
+  }
+}
+    `;
+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 GetSlotsDocument = gql`
-    query GetSlots($first: Int = 100, $skip: Int = 0, $orderBy: Slot_orderBy, $orderDirection: OrderDirection, $where: Slot_filter) {
+    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
   ) {
-    id
-    land {
-      id
-      owner
-    }
-    slotId
-    occupant
-    currency
-    basePrice
-    price
-    taxPercentage
-    maxTaxPercentage
-    minTaxUpdatePeriod
-    module
-    active
-    createdAt
-    updatedAt
+    ...SlotFields
   }
 }
-    `;
+    ${SlotFieldsFragmentDoc}`;
 var GetSlotDocument = gql`
-    query GetSlot($id: ID!) {
-  slot(id: $id) {
-    id
-    land {
-      id
-      owner
-    }
-    slotId
-    occupant
-    currency
-    basePrice
-    price
-    taxPercentage
-    maxTaxPercentage
-    minTaxUpdatePeriod
-    module
-    active
-    createdAt
-    updatedAt
-    priceHistory(orderBy: timestamp, orderDirection: desc, first: 10) {
-      id
-      oldPrice
-      newPrice
-      timestamp
-      tx
-    }
-    taxUpdates(orderBy: timestamp, orderDirection: desc, first: 10) {
-      id
-      kind
-      oldPercentage
-      newPercentage
-      confirmableAt
-      timestamp
-      tx
-    }
+    query GetSlot($id: ID!, $block: Block_height) {
+  slot(id: $id, block: $block) {
+    ...SlotFields
   }
 }
-    `;
-var GetSlotsByOccupantDocument = gql`
-    query GetSlotsByOccupant($occupant: Bytes!, $first: Int = 100) {
-  slots(where: {occupant: $occupant, active: true}, first: $first) {
-    id
-    land {
-      id
-    }
-    slotId
-    occupant
-    price
-    taxPercentage
-    active
+    ${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
   }
 }
-    `;
-var GetAvailableSlotsDocument = gql`
-    query GetAvailableSlots($first: Int = 100, $skip: Int = 0) {
+    ${SlotFieldsFragmentDoc}`;
+var GetSlotsByOccupantDocument = gql`
+    query GetSlotsByOccupant($occupant: Bytes!, $first: Int!, $skip: Int, $orderBy: Slot_orderBy, $orderDirection: OrderDirection, $block: Block_height) {
   slots(
-    where: {occupant: null, active: true}
     first: $first
     skip: $skip
-    orderBy: price
-    orderDirection: asc
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: {occupant: $occupant}
+    block: $block
   ) {
-    id
-    land {
-      id
-      owner
-    }
-    slotId
-    currency
-    price
-    taxPercentage
+    ...SlotFields
   }
 }
-    `;
+    ${SlotFieldsFragmentDoc}`;
 var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
 function getSdk(client, withWrapper = defaultWrapper) {
   return {
-    GetSlotPurchases(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotPurchasesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotPurchases", "query", variables);
+    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);
+    },
+    GetRecentEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetRecentEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetRecentEvents", "query", variables);
     },
-    GetLandOpenedEvents(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandOpenedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLandOpenedEvents", "query", variables);
+    GetBoughtEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBoughtEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetBoughtEvents", "query", variables);
     },
-    GetSlotCreatedEvents(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotCreatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotCreatedEvents", "query", variables);
+    GetReleasedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetReleasedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetReleasedEvents", "query", variables);
     },
-    GetPriceUpdates(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPriceUpdatesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetPriceUpdates", "query", variables);
+    GetLiquidatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLiquidatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLiquidatedEvents", "query", variables);
     },
-    GetHub(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetHubDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetHub", "query", variables);
+    GetSettledEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSettledEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSettledEvents", "query", variables);
     },
-    GetAllowedModules(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAllowedModulesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAllowedModules", "query", variables);
+    GetTaxCollectedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTaxCollectedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetTaxCollectedEvents", "query", variables);
     },
-    GetAllowedCurrencies(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAllowedCurrenciesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAllowedCurrencies", "query", variables);
+    GetDepositedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetDepositedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetDepositedEvents", "query", variables);
     },
-    GetLands(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLands", "query", variables);
+    GetWithdrawnEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetWithdrawnEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetWithdrawnEvents", "query", variables);
     },
-    GetLand(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLand", "query", variables);
+    GetPriceUpdatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPriceUpdatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetPriceUpdatedEvents", "query", variables);
     },
-    GetLandsByOwner(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandsByOwnerDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLandsByOwner", "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);
     },
     GetSlots(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlots", "query", variables);
@@ -329,16 +613,26 @@ function getSdk(client, withWrapper = defaultWrapper) {
     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);
-    },
-    GetAvailableSlots(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAvailableSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAvailableSlots", "query", variables);
     }
   };
 }
-
-// src/client.ts
+var META_QUERY = gql$1`
+  query GetMeta {
+    _meta {
+      block {
+        number
+        hash
+        timestamp
+      }
+      hasIndexingErrors
+    }
+  }
+`;
 var SlotsChain = /* @__PURE__ */ ((SlotsChain2) => {
   SlotsChain2[SlotsChain2["BASE_SEPOLIA"] = 84532] = "BASE_SEPOLIA";
   SlotsChain2[SlotsChain2["ARBITRUM"] = 42161] = "ARBITRUM";
@@ -349,72 +643,46 @@ var SUBGRAPH_URLS = {
   [42161 /* ARBITRUM */]: "https://api.studio.thegraph.com/query/958/0-x-slots-arb/version/latest"
 };
 var SlotsClient = class {
-  /**
-   * Create a new SlotsClient instance
-   *
-   * @param config - Client configuration
-   *
-   * @example
-   * ```typescript
-   * import { SlotsClient, SlotsChain } from '@0xslots/sdk';
-   *
-   * const client = new SlotsClient({
-   *   chainId: SlotsChain.BASE_SEPOLIA,
-   * });
-   *
-   * const hub = await client.getHub({ id: '0x...' });
-   * ```
-   */
   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 configured for chain ${config.chainId}`);
-    }
-    this.client = new GraphQLClient(url, {
-      headers: config.headers
-    });
-    this.sdk = getSdk(this.client);
+    if (!url) throw new Error(`No subgraph URL for chain ${config.chainId}`);
+    this.gqlClient = new GraphQLClient(url, { headers: config.headers });
+    this.sdk = getSdk(this.gqlClient);
   }
-  /**
-   * Get the current chain ID
-   */
+  // ─── Accessors ──────────────────────────────────────────────────────────────
   getChainId() {
     return this.chainId;
   }
-  /**
-   * Get the underlying GraphQL client
-   */
   getClient() {
-    return this.client;
+    return this.gqlClient;
   }
-  /**
-   * Get the generated SDK with all typed query methods
-   */
   getSdk() {
     return this.sdk;
   }
-  // Convenience methods that proxy to the SDK
-  // Hub queries
-  getHub(...args) {
-    return this.sdk.GetHub(...args);
-  }
-  getAllowedModules(...args) {
-    return this.sdk.GetAllowedModules(...args);
+  get publicClient() {
+    if (!this._publicClient) throw new Error("No publicClient provided");
+    return this._publicClient;
   }
-  getAllowedCurrencies(...args) {
-    return this.sdk.GetAllowedCurrencies(...args);
+  get factory() {
+    if (!this._factory) throw new Error("No factoryAddress provided");
+    return this._factory;
   }
-  // Land queries
-  getLands(...args) {
-    return this.sdk.GetLands(...args);
+  get wallet() {
+    if (!this.walletClient) throw new Error("No walletClient provided");
+    return this.walletClient;
   }
-  getLand(...args) {
-    return this.sdk.GetLand(...args);
-  }
-  getLandsByOwner(...args) {
-    return this.sdk.GetLandsByOwner(...args);
+  get account() {
+    const account = this.wallet.account;
+    if (!account) throw new Error("WalletClient must have an account");
+    return account.address;
   }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // READ — Subgraph Queries
+  // ═══════════════════════════════════════════════════════════════════════════
   // Slot queries
   getSlots(...args) {
     return this.sdk.GetSlots(...args);
@@ -422,30 +690,338 @@ var SlotsClient = class {
   getSlot(...args) {
     return this.sdk.GetSlot(...args);
   }
+  getSlotsByRecipient(...args) {
+    return this.sdk.GetSlotsByRecipient(...args);
+  }
   getSlotsByOccupant(...args) {
     return this.sdk.GetSlotsByOccupant(...args);
   }
-  getAvailableSlots(...args) {
-    return this.sdk.GetAvailableSlots(...args);
+  // Factory queries
+  getFactory() {
+    return this.sdk.GetFactory();
+  }
+  getModules(...args) {
+    return this.sdk.GetModules(...args);
   }
   // Event queries
-  getSlotPurchases(...args) {
-    return this.sdk.GetSlotPurchases(...args);
+  getBoughtEvents(...args) {
+    return this.sdk.GetBoughtEvents(...args);
+  }
+  getSettledEvents(...args) {
+    return this.sdk.GetSettledEvents(...args);
+  }
+  getTaxCollectedEvents(...args) {
+    return this.sdk.GetTaxCollectedEvents(...args);
+  }
+  getSlotActivity(...args) {
+    return this.sdk.GetSlotActivity(...args);
+  }
+  getRecentEvents(...args) {
+    return this.sdk.GetRecentEvents(...args);
+  }
+  // Account queries
+  getAccount(...args) {
+    return this.sdk.GetAccount(...args);
+  }
+  getAccounts(...args) {
+    return this.sdk.GetAccounts(...args);
+  }
+  // Individual event queries
+  getReleasedEvents(...args) {
+    return this.sdk.GetReleasedEvents(...args);
+  }
+  getLiquidatedEvents(...args) {
+    return this.sdk.GetLiquidatedEvents(...args);
+  }
+  getDepositedEvents(...args) {
+    return this.sdk.GetDepositedEvents(...args);
+  }
+  getWithdrawnEvents(...args) {
+    return this.sdk.GetWithdrawnEvents(...args);
   }
-  getLandOpenedEvents(...args) {
-    return this.sdk.GetLandOpenedEvents(...args);
+  getPriceUpdatedEvents(...args) {
+    return this.sdk.GetPriceUpdatedEvents(...args);
   }
-  getSlotCreatedEvents(...args) {
-    return this.sdk.GetSlotCreatedEvents(...args);
+  // Meta
+  getMeta() {
+    return this.gqlClient.request(META_QUERY);
   }
-  getPriceUpdates(...args) {
-    return this.sdk.GetPriceUpdates(...args);
+  // ═══════════════════════════════════════════════════════════════════════════
+  // READ — On-chain (RPC)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /** Read full slot info from on-chain (RPC, not subgraph). */
+  async getSlotInfo(slot) {
+    return this.publicClient.readContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "getSlotInfo"
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Factory Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  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.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  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.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Slot Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /** Buy a slot (or force buy an occupied one). Handles ERC-20 approval automatically. */
+  async buy(params) {
+    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). */
+  async selfAssess(slot, newPrice) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "selfAssess",
+      args: [newPrice],
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Top up deposit on a slot (occupant only). Handles ERC-20 approval automatically. */
+  async topUp(slot, amount) {
+    return this.withAllowance(slot, amount, {
+      to: slot,
+      abi: slotAbi,
+      functionName: "topUp",
+      args: [amount]
+    });
+  }
+  /** Withdraw from deposit (occupant only). Cannot go below minimum deposit. */
+  async withdraw(slot, amount) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "withdraw",
+      args: [amount],
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Release a slot (occupant only). Returns remaining deposit. */
+  async release(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "release",
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Collect accumulated tax (permissionless). */
+  async collect(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "collect",
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Liquidate an insolvent slot (permissionless). Caller receives bounty. */
+  async liquidate(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "liquidate",
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Manager Functions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /** Propose a tax rate update (manager only, slot must have mutableTax). */
+  async proposeTaxUpdate(slot, newPct) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "proposeTaxUpdate",
+      args: [newPct],
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Propose a module update (manager only, slot must have mutableModule). */
+  async proposeModuleUpdate(slot, newModule) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "proposeModuleUpdate",
+      args: [newModule],
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Cancel pending updates (manager only). */
+  async cancelPendingUpdates(slot) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "cancelPendingUpdates",
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  /** Set liquidation bounty bps (manager only). */
+  async setLiquidationBounty(slot, newBps) {
+    return this.wallet.writeContract({
+      address: slot,
+      abi: slotAbi,
+      functionName: "setLiquidationBounty",
+      args: [newBps],
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WRITE — Multicall
+  // ═══════════════════════════════════════════════════════════════════════════
+  /** Batch multiple slot calls into one transaction via multicall. */
+  async multicall(slot, calls) {
+    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.wallet.account,
+      chain: this.wallet.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.wallet.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.wallet.account,
+        chain: this.wallet.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.wallet.account,
+        chain: this.wallet.chain
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+    }
+    return this.wallet.writeContract({
+      address: call.to,
+      abi: call.abi,
+      functionName: call.functionName,
+      args: call.args,
+      account: this.wallet.account,
+      chain: this.wallet.chain
+    });
   }
 };
 function createSlotsClient(config) {
   return new SlotsClient(config);
 }
 
-export { GetAllowedCurrenciesDocument, GetAllowedModulesDocument, GetAvailableSlotsDocument, GetHubDocument, GetLandDocument, GetLandOpenedEventsDocument, GetLandsByOwnerDocument, GetLandsDocument, GetPriceUpdatesDocument, GetSlotCreatedEventsDocument, GetSlotDocument, GetSlotPurchasesDocument, GetSlotsByOccupantDocument, GetSlotsDocument, SUBGRAPH_URLS, SlotsChain, SlotsClient, createSlotsClient, getSdk };
+export { AccountFieldsFragmentDoc, GetAccountDocument, GetAccountsDocument, GetBoughtEventsDocument, GetDepositedEventsDocument, GetFactoryDocument, GetLiquidatedEventsDocument, GetModulesDocument, GetPriceUpdatedEventsDocument, GetRecentEventsDocument, GetReleasedEventsDocument, GetSettledEventsDocument, GetSlotActivityDocument, GetSlotDocument, GetSlotsByOccupantDocument, GetSlotsByRecipientDocument, GetSlotsDocument, GetTaxCollectedEventsDocument, GetWithdrawnEventsDocument, SUBGRAPH_URLS, SlotFieldsFragmentDoc, SlotsChain, SlotsClient, createSlotsClient, getSdk };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map