@iota/kiosk 0.6.2 → 0.8.0

package/src/query/kiosk.ts

@@ -3,10 +3,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type {
+    PaginatedObjectsResponse,
     PaginationArguments,
     IotaClient,
     IotaObjectData,
-    IotaObjectDataFilter,
     IotaObjectResponse,
 } from '@iota/iota-sdk/client';
 import { isValidIotaAddress } from '@iota/iota-sdk/utils';
@@ -29,6 +29,10 @@ import {
     getKioskObject,
 } from '../utils.js';
 
+const DEFAULT_PAGE_SIZE = 50;
+const PERSONAL_KIOSKS_CURSOR = 'personal';
+const OWNED_KIOSKS_CURSOR = 'owned';
+
 export async function fetchKiosk(
     client: IotaClient,
     kioskId: string,
@@ -99,45 +103,121 @@ export async function getOwnedKiosks(
         personalKioskType: string;
     },
 ): Promise<OwnedKiosks> {
-    if (!isValidIotaAddress(address))
+    // TODO: this should throw an error, but I am not going to change it right now incase it breaks existing code.
+    if (!isValidIotaAddress(address)) {
         return {
             nextCursor: null,
             hasNextPage: false,
             kioskOwnerCaps: [],
             kioskIds: [],
         };
+    }
 
-    const filter: IotaObjectDataFilter = {
-        MatchAny: [
-            {
-                StructType: KIOSK_OWNER_CAP,
-            },
-        ],
-    };
+    const limit = options?.pagination?.limit ?? DEFAULT_PAGE_SIZE;
+    const [cursorType, cursor] = options?.pagination?.cursor?.split(':') ?? [
+        PERSONAL_KIOSKS_CURSOR,
+        null,
+    ];
+
+    if (options?.personalKioskType && cursorType === PERSONAL_KIOSKS_CURSOR) {
+        const personalKioskResponse = formatOwnedKioskResponse(
+            await client.getOwnedObjects({
+                owner: address,
+                filter: {
+                    StructType: options.personalKioskType,
+                },
+                options: {
+                    showContent: true,
+                    showType: true,
+                },
+                cursor,
+                limit,
+            }),
+            PERSONAL_KIOSKS_CURSOR,
+        );
 
-    if (options?.personalKioskType) {
-        filter.MatchAny.push({
-            StructType: options.personalKioskType,
-        });
+        if (personalKioskResponse.hasNextPage) {
+            return personalKioskResponse;
+        }
+
+        const remainingLimit = limit - personalKioskResponse.kioskOwnerCaps.length;
+
+        // If we have all personal kiosks, but don't have space for the owned kiosks
+        // we need to start loading owned kiosks for the next page, but don't have a real cursor
+        if (remainingLimit < 1) {
+            return {
+                nextCursor: `${OWNED_KIOSKS_CURSOR}:`,
+                hasNextPage: true,
+                kioskOwnerCaps: personalKioskResponse.kioskOwnerCaps,
+                kioskIds: personalKioskResponse.kioskIds,
+            };
+        }
+
+        const ownedKiosksResponse = formatOwnedKioskResponse(
+            await client.getOwnedObjects({
+                owner: address,
+                filter: {
+                    StructType: KIOSK_OWNER_CAP,
+                },
+                options: {
+                    showContent: true,
+                    showType: true,
+                },
+                limit: remainingLimit,
+            }),
+            OWNED_KIOSKS_CURSOR,
+        );
+
+        return {
+            nextCursor: ownedKiosksResponse.nextCursor,
+            hasNextPage: ownedKiosksResponse.hasNextPage,
+            kioskOwnerCaps: [
+                ...personalKioskResponse.kioskOwnerCaps,
+                ...ownedKiosksResponse.kioskOwnerCaps,
+            ],
+            kioskIds: [...personalKioskResponse.kioskIds, ...ownedKiosksResponse.kioskIds],
+        };
     }
 
-    // fetch owned kiosk caps, paginated.
-    const { data, hasNextPage, nextCursor } = await client.getOwnedObjects({
-        owner: address,
-        filter,
-        options: {
-            showContent: true,
-            showType: true,
-        },
-        ...(options?.pagination || {}),
-    });
+    return formatOwnedKioskResponse(
+        await client.getOwnedObjects({
+            owner: address,
+            filter: {
+                StructType: KIOSK_OWNER_CAP,
+            },
+            options: {
+                showContent: true,
+                showType: true,
+            },
+            // cursor might be an empty string if the number of personal kiosks was a multiple of the limit.
+            cursor: cursor ? cursor : null,
+            limit,
+        }),
+        OWNED_KIOSKS_CURSOR,
+    );
+}
+
+function formatOwnedKioskResponse(
+    response: PaginatedObjectsResponse,
+    cursorType: string,
+): OwnedKiosks {
+    const { data, hasNextPage, nextCursor } = response;
 
     // get kioskIds from the OwnerCaps.
     const kioskIdList = data?.map((x: IotaObjectResponse) => {
-        const fields = x.data?.content?.dataType === 'moveObject' ? x.data.content.fields : null;
-        // @ts-expect-error TODO: should i remove ts ignore here?
-        return (fields?.cap ? fields?.cap?.fields?.for : fields?.for) as string;
-        // return (fields as { for: string })?.for;
+        const fields =
+            x.data?.content?.dataType === 'moveObject'
+                ? (x.data.content.fields as unknown as
+                      | {
+                            cap: { fields: { for: string } };
+                            for?: never;
+                        }
+                      | {
+                            cap?: never;
+                            for: string;
+                        })
+                : null;
+        return fields?.cap ? fields?.cap?.fields?.for : (fields?.for as string);
     });
 
     // clean up data that might have an error in them.
@@ -145,7 +225,7 @@ export async function getOwnedKiosks(
     const filteredData = data.filter((x) => 'data' in x).map((x) => x.data) as IotaObjectData[];
 
     return {
-        nextCursor,
+        nextCursor: nextCursor ? `${cursorType}:${nextCursor}` : nextCursor,
         hasNextPage,
         kioskOwnerCaps: filteredData.map((x, idx) => ({
             isPersonal: x.type !== KIOSK_OWNER_CAP,

package/src/tx/rules/resolve.ts

@@ -1,25 +1,64 @@
 // Copyright (c) Mysten Labs, Inc.
-// Modifications Copyright (c) 2024 IOTA Stiftung
+// Modifications Copyright (c) 2026 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+import { bcs } from '@iota/iota-sdk/bcs';
+import type { TransactionArgument } from '@iota/iota-sdk/transactions';
+import { Transaction } from '@iota/iota-sdk/transactions';
+import { normalizeIotaAddress } from '@iota/iota-sdk/utils';
+
 import type { RuleResolvingParams } from '../../types/index.js';
 import { lock } from '../kiosk.js';
 
 /**
  * A helper to resolve the royalty rule.
  */
-export function resolveRoyaltyRule(params: RuleResolvingParams) {
-    const { transaction: tx, itemType, price, packageId, transferRequest, policyId } = params;
+export async function resolveRoyaltyRule(params: RuleResolvingParams) {
+    const {
+        kioskClient,
+        transaction: tx,
+        itemType,
+        price,
+        packageId,
+        transferRequest,
+        policyId,
+    } = params;
 
-    const policyObj = tx.object(policyId);
+    // We attempt to resolve the fee amount outside of the PTB so that the split amount is known before the transaction is sent.
+    // This improves the display of the transaction within the wallet.
 
+    const feeTx = new Transaction();
     // calculates the amount
-    const [amount] = tx.moveCall({
+    feeTx.moveCall({
         target: `${packageId}::royalty_rule::fee_amount`,
         typeArguments: [itemType],
-        arguments: [policyObj, tx.pure.u64(price || '0')],
+        arguments: [feeTx.object(policyId), feeTx.pure.u64(price || '0')],
     });
 
+    const policyObj = tx.object(policyId);
+
+    const { results } = await kioskClient.client.devInspectTransactionBlock({
+        sender: tx.getData().sender || normalizeIotaAddress('0x0'),
+        transactionBlock: feeTx,
+    });
+
+    let amount: TransactionArgument | bigint | null = null;
+    if (results) {
+        const returnedAmount = results?.[0].returnValues?.[0]?.[0];
+        if (returnedAmount) {
+            amount = BigInt(bcs.U64.parse(new Uint8Array(returnedAmount as number[])));
+        }
+    }
+
+    // We were not able to calculate the amount outside of the transaction, so fall back to resolving it within the PTB
+    if (!amount) {
+        [amount] = tx.moveCall({
+            target: `${packageId}::royalty_rule::fee_amount`,
+            typeArguments: [itemType],
+            arguments: [policyObj, tx.pure.u64(price || '0')],
+        });
+    }
+
     // splits the coin.
     const feeCoin = tx.splitCoins(tx.gas, [amount]);
 

package/src/types/transfer-policy.ts

@@ -5,6 +5,7 @@
 import type { ObjectOwner } from '@iota/iota-sdk/client';
 import type { Transaction, TransactionObjectArgument } from '@iota/iota-sdk/transactions';
 
+import type { KioskClient } from '../client/kiosk-client.js';
 import type { ObjectArgument } from './index.js';
 
 /** The Transfer Policy module. */
@@ -54,8 +55,6 @@ export type TransferPolicyCreated = {
 // e.g. `if(!'my_key' in ruleParams!) throw new Error("Can't resolve that rule!")`
 export type RuleResolvingParams = {
     transaction: Transaction;
-    /** @deprecated use transaction instead */
-    transactionBlock: Transaction;
     itemType: string;
     itemId: string;
     price: string;
@@ -67,4 +66,6 @@ export type RuleResolvingParams = {
     purchasedItem: TransactionObjectArgument;
     packageId: string;
     extraArgs: Record<string, any>; // extraParams contains more possible {key, values} to pass for custom rules.
+
+    kioskClient: KioskClient;
 };