@0xslots/sdk 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,327 +1,538 @@
-import { GraphQLClient } from 'graphql-request';
+import { gql as gql$1, GraphQLClient } from 'graphql-request';
 import gql from 'graphql-tag';
 
 // 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
+  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
-    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) {
+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
-    protocolFeeBps
-    protocolFeeRecipient
-    landCreationFee
-    slotExpansionFee
-    defaultCurrency {
+    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
+    occupant
+    refund
+    timestamp
+    tx
+  }
+  liquidatedEvents(
+    first: $first
+    orderBy: timestamp
+    orderDirection: desc
+    where: {slot: $slotId}
+  ) {
     id
-    owner
-    createdAt
-    createdTx
+    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
+  }
+}
+    `;
+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);
+    },
+    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);
     },
-    GetLandOpenedEvents(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandOpenedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLandOpenedEvents", "query", variables);
+    GetLiquidatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLiquidatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLiquidatedEvents", "query", variables);
     },
-    GetSlotCreatedEvents(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotCreatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotCreatedEvents", "query", variables);
+    GetSettledEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSettledEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSettledEvents", "query", variables);
     },
-    GetPriceUpdates(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPriceUpdatesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetPriceUpdates", "query", variables);
+    GetTaxCollectedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTaxCollectedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetTaxCollectedEvents", "query", variables);
     },
-    GetHub(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetHubDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetHub", "query", variables);
+    GetDepositedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetDepositedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetDepositedEvents", "query", variables);
     },
-    GetAllowedModules(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAllowedModulesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAllowedModules", "query", variables);
+    GetWithdrawnEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetWithdrawnEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetWithdrawnEvents", "query", variables);
     },
-    GetAllowedCurrencies(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetAllowedCurrenciesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetAllowedCurrencies", "query", variables);
+    GetPriceUpdatedEvents(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPriceUpdatedEventsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetPriceUpdatedEvents", "query", variables);
     },
-    GetLands(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLands", "query", variables);
+    GetSlotActivity(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetSlotActivityDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetSlotActivity", "query", variables);
     },
-    GetLand(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLand", "query", variables);
+    GetFactory(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetFactoryDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetFactory", "query", variables);
     },
-    GetLandsByOwner(variables, requestHeaders, signal) {
-      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLandsByOwnerDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetLandsByOwner", "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,92 +540,54 @@ 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";
   return SlotsChain2;
 })(SlotsChain || {});
 var SUBGRAPH_URLS = {
-  [84532 /* BASE_SEPOLIA */]: "https://api.studio.thegraph.com/query/958/0-x-slots-base-sepolia/version/latest",
+  [84532 /* BASE_SEPOLIA */]: "https://api.studio.thegraph.com/query/958/0-x-slots-base-sepolia/v3.5.0",
   [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;
     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
-    });
+    if (!url) throw new Error(`No subgraph URL for chain ${config.chainId}`);
+    this.client = new GraphQLClient(url, { headers: config.headers });
     this.sdk = getSdk(this.client);
   }
-  /**
-   * Get the current chain ID
-   */
   getChainId() {
     return this.chainId;
   }
-  /**
-   * Get the underlying GraphQL client
-   */
   getClient() {
     return this.client;
   }
-  /**
-   * 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);
-  }
-  getAllowedCurrencies(...args) {
-    return this.sdk.GetAllowedCurrencies(...args);
-  }
-  // Land queries
-  getLands(...args) {
-    return this.sdk.GetLands(...args);
-  }
-  getLand(...args) {
-    return this.sdk.GetLand(...args);
-  }
-  getLandsByOwner(...args) {
-    return this.sdk.GetLandsByOwner(...args);
-  }
   // Slot queries
   getSlots(...args) {
     return this.sdk.GetSlots(...args);
@@ -422,30 +595,67 @@ 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 (full params)
+  getReleasedEvents(...args) {
+    return this.sdk.GetReleasedEvents(...args);
+  }
+  getLiquidatedEvents(...args) {
+    return this.sdk.GetLiquidatedEvents(...args);
+  }
+  getDepositedEvents(...args) {
+    return this.sdk.GetDepositedEvents(...args);
   }
-  getLandOpenedEvents(...args) {
-    return this.sdk.GetLandOpenedEvents(...args);
+  getWithdrawnEvents(...args) {
+    return this.sdk.GetWithdrawnEvents(...args);
   }
-  getSlotCreatedEvents(...args) {
-    return this.sdk.GetSlotCreatedEvents(...args);
+  getPriceUpdatedEvents(...args) {
+    return this.sdk.GetPriceUpdatedEvents(...args);
   }
-  getPriceUpdates(...args) {
-    return this.sdk.GetPriceUpdates(...args);
+  // Meta
+  getMeta() {
+    return this.client.request(META_QUERY);
   }
 };
 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