diff --git a/docs/examples/move/nft_marketplace/Move.toml b/docs/examples/move/nft_marketplace/Move.toml new file mode 100644 index 00000000000..11388926dfb --- /dev/null +++ b/docs/examples/move/nft_marketplace/Move.toml @@ -0,0 +1,35 @@ +[package] +name = "nft_marketplace" +edition = "2024.beta" + +[dependencies] +Iota = { local = "../../../../crates/iota-framework/packages/iota-framework" } +Kiosk = { local = "../../../../kiosk" } + +# For remote import, use the `{ git = "...", subdir = "...", rev = "..." }`. +# Revision can be a branch, a tag, and a commit hash. +# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" } + +# For local dependencies use `local = path`. Path is relative to the package root +# Local = { local = "../path/to" } + +# To resolve a version conflict and force a specific version for dependency +# override use `override = true` +# Override = { local = "../conflicting/version", override = true } + +[addresses] +nft_marketplace = "0x0" + +# Named addresses will be accessible in Move as `@name`. They're also exported: +# for example, `std = "0x1"` is exported by the Standard Library. +# alice = "0xA11CE" + +[dev-dependencies] +# The dev-dependencies section allows overriding dependencies for `--test` and +# `--dev` modes. You can introduce test-only dependencies here. +# Local = { local = "../path/to/dev-build" } + +[dev-addresses] +# The dev-addresses section allows overwriting named addresses for the `--test` +# and `--dev` modes. +# alice = "0xB0B" diff --git a/docs/examples/move/nft_marketplace/README.md b/docs/examples/move/nft_marketplace/README.md new file mode 100644 index 00000000000..42cb414ab65 --- /dev/null +++ b/docs/examples/move/nft_marketplace/README.md @@ -0,0 +1,214 @@ +# Marketplace Guide + +## Modules + +The [`marketplace_extension.move`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/marketplace_extension.move) +module provides a straightforward implementation of a marketplace extension. To use it, follow the +[steps outlined below](#how-to-use-the-marketplace). + +The [`clothing_store.move`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/clothing_store.move) module contains mocked item data for +use within the marketplace. + +The [`rental_extension.move`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/rental_extension.move) module adds the functionality to enable item rentals. + +## How To Use the Marketplace + +### 1. Install the IOTA CLI and Connect to the Network + +The first thing you'll need to do is [install the IOTA CLI](https://docs.iota.org/developer/getting-started/install-iota), [connect to an IOTA network](https://docs.iota.org/developer/getting-started/connect) and [get some test tokens](https://docs.iota.org/developer/getting-started/get-coins) to pay for [gas](https://docs.iota.org/about-iota/tokenomics/gas-in-iota). + +### 2. Install Kiosk + +You can install the Kiosk by creating a `Kiosk` object, which will also create its `OwnerCap`, and then transferring +them to the caller. + +Run the following command to install the Kiosk module: + +```bash +iota client call \ + --package 0x2 \ + --module kiosk \ + --function default +``` + +After publishing, export the following variables: + +- `KIOSK_ID`: The ID of the installed Kiosk object. +- `KIOSK_CAP_ID`: The ID of the installed Kiosk's owner cap + +### 3. Publish `nft_marketplace` package + +#### 3.1(Optional) Publish Kiosk rules modules if these are not present in the network you are using + +You can publish Kiosk rules modules(package) using the following command: + +```bash +iota client publish $IOTA_REPO_DIR/kiosk +``` + +After publishing, export the following variable: + +- `RULES_PACKAGE_ID`: The ID of the rules package. + +#### 3.2 Publish the `nft_marketplace` Package + +```bash +iota client publish $IOTA_REPO_DIR/docs/examples/move/nft_marketplace +``` + +After publishing, export the following variables: + +- `MARKETPLACE_PACKAGE_ID`: The ID of the whole marketplace package. +- `MARKETPLACE_PUBLISHER_ID`: The ID of the publisher object created during marketplace package publishing." + +### 4. Create a Clothing Store Item + +Next, you should use the functions in the `clothing_store` module to create an item, for instance: + +```bash +iota client call \ + --package $MARKETPLACE_PACKAGE_ID \ + --module clothing_store \ + --function new_jeans +``` + +After creation, export the following variable: + +- `CLOTHING_STORE_ITEM_ID`: The ID of the published item (in this case, Jeans). + +### 5. Create a Transfer Policy + +`TransferPolicy` is a generic-shared object that acts as a central authority enforcing that everyone checks their +purchase is valid against the defined policy before the purchased item is transferred to the buyer. The object is +specified by concrete type: +The `default` function creates a `TransferPolicy` object and a `TransferPolicyCap`, then transfers them to the caller. + +The `TransferPolicyCap` object serves as proof of ownership of the `TransferPolicy` object. +A capability granting the owner permission to `add/remove` rules, `withdraw`, and `destroy_and_withdraw` the `TransferPolicy`. + +You can set up a transfer policy for the created item using the following command: + +```bash +iota client call \ + --package 0x2 \ + --module transfer_policy \ + --function default \ + --gas-budget 10000000 \ + --args $MARKETPLACE_PUBLISHER_ID \ + --type-args "$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans" +``` + +After publishing, export the following variables: + +- `ITEM_TRANS_POLICY`: The ID of the item transfer policy object. +- `ITEM_TRANS_POLICY_CAP`: The ID of the item transfer policy object owner capability" + +### 6. Install the Extension on the Kiosk + +The [`install`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/marketplace_extension.move#L39-L45) function enables the installation of the Marketplace extension in a kiosk. +Under the hood, it invokes `kiosk_extension::add`, which adds an extension to the Kiosk via a [dynamic field](https://docs.iota.org/developer/iota-101/objects/dynamic-fields/). +You can install the marketplace extension on the created kiosk using the following command: + +```bash +iota client call \ + --package $MARKETPLACE_PACKAGE_ID \ + --module marketplace_extension \ + --function install \ + --args $KIOSK_ID $KIOSK_CAP_ID +``` + +### 7. Set a Price for the Item + +You can use the [`set_price`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/marketplace_extension.move#L98-L114) function to set the price for the item: + +```bash +iota client call \ + --package $MARKETPLACE_PACKAGE_ID \ + --module marketplace_extension \ + --function set_price \ + --args $KIOSK_ID $KIOSK_CAP_ID $CLOTHING_STORE_ITEM_ID 50000 \ + --type-args "$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans" +``` + +### 8.(Optional) Set Royalties + +Royalties are a percentage of the item's price or revenue paid to the owner for using or selling their asset. + +You can use the [`set_royalties`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/marketplace_extension.move#L58-L60) function to set royalties for the item: + +```bash +iota client call \ + --package $MARKETPLACE_PACKAGE_ID \ + --module marketplace_extension \ + --function setup_royalties \ + --args $ITEM_TRANS_POLICY $ITEM_TRANS_POLICY_CAP 5000 2000 \ + --type-args "$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans" +``` + +### 9. Buy an Item + +#### 9.1 Get the Item Price + +You can use the following [Programmable Transaction Block](https://docs.iota.org/developer/iota-101/transactions/ptb/programmable-transaction-blocks-overview) to call the +[`get_item_price`](https://github.com/iotaledger/iota/blob/develop/docs/examples/move/nft_marketplace/sources/marketplace_extension.move#L116-L127) +and assign it to an `item_price` variable. In this case, the Jeans item: + +```bash +iota client ptb \ +--move-call $MARKETPLACE_PACKAGE_ID::marketplace_extension::get_item_price "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$KIOSK_ID @$CLOTHING_STORE_ITEM_ID --assign item_price \ +``` + +#### 9.2(Optional) Calculate the Royalties For the Item + +You can use the following [move-call](https://docs.iota.org/references/cli/ptb#move-call) to get the royalties for any given product by calling the `kiosk::royalty_rule::fee_amount` function +and assign it to a `royalties_amount` variable. In this case, the Jeans item: + +```bash +--move-call $RULES_PACKAGE_ID::royalty_rule::fee_amount "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$ITEM_TRANS_POLICY item_price --assign royalties_amount \ +``` + +#### 9.3 Create a Payment Coin With a Specific Amount (Price + Optional Royalties) + +You can use the following command to [split your gas tokens](https://docs.iota.org/references/cli/ptb#split-destroy-and-merge-coins) to pay for the item's price and royalties: + +```bash +--split-coins gas "[item_price, royalties_amount]" --assign payment_coins \ +--merge-coins payment_coins.0 "[payment_coins.1]" \ +``` + +#### 9.4 Buy an Item Using `payment_coins.0` + +You can use the following [move-call](https://docs.iota.org/references/cli/ptb#move-call) to pay the owner the item's price. +If the royalty rule is enabled, an additional royalty fee, calculated as a percentage of the initial item price, is also +paid. +Once both payments are completed, the item is ready for transfer to the buyer. + +To purchase the item: + +```bash +--move-call $MARKETPLACE_PACKAGE_ID::marketplace_extension::buy_item "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$KIOSK_ID @$ITEM_TRANS_POLICY @$CLOTHING_STORE_ITEM_ID payment_coins.0 --assign purchased_item +``` + +#### 9.5 Transfer an Item to the Buyer + +Finally, you can set up the +[public_transfer](https://docs.iota.org/references/framework/iota-framework/transfer#function-public_transfer) to +transfer the purchased item to the buyer: + +```bash +--move-call 0x2::transfer::public_transfer "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" purchased_item @ \ +``` + +You can combine all the previous steps into one purchase +[PTB](https://docs.iota.org/developer/iota-101/transactions/ptb/programmable-transaction-blocks-overview) request, +including royalties, which should look like this: + +```bash +iota client ptb \ +--move-call $MARKETPLACE_PACKAGE_ID::marketplace_extension::get_item_price "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$KIOSK_ID @$CLOTHING_STORE_ITEM_ID --assign item_price \ +--move-call $RULES_PACKAGE_ID::royalty_rule::fee_amount "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$ITEM_TRANS_POLICY item_price --assign royalties_amount \ +--split-coins gas "[item_price, royalties_amount]" --assign payment_coins \ +--merge-coins payment_coins.0 "[payment_coins.1]" \ +--move-call $MARKETPLACE_PACKAGE_ID::marketplace_extension::buy_item "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" @$KIOSK_ID @$ITEM_TRANS_POLICY @$CLOTHING_STORE_ITEM_ID payment_coins.0 --assign purchased_item \ +--move-call 0x2::transfer::public_transfer "<$MARKETPLACE_PACKAGE_ID::clothing_store::Jeans>" purchased_item @ +``` diff --git a/docs/examples/move/nft_marketplace/sources/clothing_store.move b/docs/examples/move/nft_marketplace/sources/clothing_store.move new file mode 100644 index 00000000000..050c8f93a75 --- /dev/null +++ b/docs/examples/move/nft_marketplace/sources/clothing_store.move @@ -0,0 +1,60 @@ +/// Module provides `mock` items for using them in marketplace and rental extensions. +#[allow(lint(self_transfer))] +module nft_marketplace::clothing_store { + use iota::package; + /// One Time Witness. + public struct CLOTHING_STORE has drop {} + + + fun init(otw: CLOTHING_STORE, ctx: &mut TxContext) { + package::claim_and_keep(otw, ctx) + } + + public struct TShirt has key, store { + id: UID, + } + + public struct Jacket has key, store { + id: UID, + } + + public struct Shoes has key, store { + id: UID, + } + + public struct Jeans has key, store { + id: UID, + } + + public fun new_tshirt(ctx: &mut TxContext) { + let tshirt = TShirt { + id: object::new(ctx), + }; + + transfer::public_transfer(tshirt, ctx.sender()); + } + + public fun new_jeans(ctx: &mut TxContext) { + let jeans = Jeans { + id: object::new(ctx), + }; + + transfer::public_transfer(jeans, ctx.sender()); + } + + public fun new_shoes(ctx: &mut TxContext) { + let shoes = Shoes { + id: object::new(ctx), + }; + + transfer::public_transfer(shoes, ctx.sender()); + } + + public fun new_jacket(ctx: &mut TxContext) { + let jacket = Jacket { + id: object::new(ctx), + }; + + transfer::public_transfer(jacket, ctx.sender()); + } +} \ No newline at end of file diff --git a/docs/examples/move/nft_marketplace/sources/marketplace_extension.move b/docs/examples/move/nft_marketplace/sources/marketplace_extension.move new file mode 100644 index 00000000000..0531c5488a3 --- /dev/null +++ b/docs/examples/move/nft_marketplace/sources/marketplace_extension.move @@ -0,0 +1,151 @@ +module nft_marketplace::marketplace_extension { + // iota imports + use iota::{ + kiosk::{Kiosk, KioskOwnerCap, purchase}, + kiosk_extension, + bag, + transfer_policy::{Self, TransferPolicy, TransferPolicyCap, has_rule}, + coin::Coin, + iota::IOTA, + }; + + // rules imports + use kiosk::royalty_rule::Rule as RoyaltyRule; + use kiosk::royalty_rule; + + + // === Errors === + const EExtensionNotInstalled: u64 = 0; + const EWrongPaymentRoyalties: u64 = 1; + const ENotEnoughPaymentAmount: u64 = 2; + + // === Constants === + const ALLOW_PLACE_AND_LOCK: u128 = 11; + + /// Extension Key for Kiosk Marketplace extension. + public struct Marketplace has drop {} + + /// Used as a key for the item that has been up for sale that's placed in the Extension's Bag. + public struct Listed has store, copy, drop { id: ID } + + public struct ItemPrice has store { + /// Total amount of time offered for renting in days. + price: u64, + } + + // === Public Functions === + + /// Enables someone to install the Marketplace extension in their Kiosk. + public fun install( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + ctx: &mut TxContext, + ) { + kiosk_extension::add(Marketplace {}, kiosk, cap, ALLOW_PLACE_AND_LOCK, ctx); + } + + /// Remove the extension from the Kiosk. Can only be performed by the owner, + /// The extension storage must be empty for the transaction to succeed. + public fun remove(kiosk: &mut Kiosk, cap: &KioskOwnerCap, _ctx: &mut TxContext) { + kiosk_extension::remove(kiosk, cap); + } + + /// Setup item royalty percentage + /// - amount_bp - the percentage of the purchase price to be paid as a + /// fee, denominated in basis points (100_00 = 100%, 1 = 0.01%). + /// - min_amount - the minimum amount to be paid as a fee if the relative + /// amount is lower than this setting. + public fun setup_royalties(policy: &mut TransferPolicy, cap: &TransferPolicyCap, amount_bp: u16, min_amount: u64) { + royalty_rule::add(policy, cap, amount_bp, min_amount); + } + + /// Buy listed item with the indicated price and pay royalties if needed + public fun buy_item(kiosk: &mut Kiosk, policy: &mut TransferPolicy, item_id: object::ID, mut payment: Coin, ctx: &mut TxContext): T { + assert!(kiosk_extension::is_installed(kiosk), EExtensionNotInstalled); + + // Get item price + let ItemPrice { price } = take_from_bag(kiosk, Listed { id: item_id }); + + // Compute the value of the coin in input + let payment_amount_value = payment.value(); + + // If the payment_amount_value is less than the item price, the request is invalid. + assert!(payment_amount_value >= price, ENotEnoughPaymentAmount); + + // Prepare the payment coin for the purchase (if no royalties are present then the + // remaining balance will be 0 after this operation) + let coin_price = payment.split(price, ctx); + + // Purchase and create the transfer request + let (item, mut transfer_request) = purchase(kiosk, item_id, coin_price); + + // If the royalty is present, then update the request with a royalty payment + if (policy.has_rule()) { + let royalties_value = royalty_rule::fee_amount(policy, price); + assert!(payment_amount_value == price + royalties_value, EWrongPaymentRoyalties); + royalty_rule::pay(policy, &mut transfer_request, payment); + } else { + // Else clean the input coin (if the input payment amount is not exact, this will fail) + payment.destroy_zero(); + }; + + // Confirm the request + transfer_policy::confirm_request(policy, transfer_request); + item + } + + + public fun set_price( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + item: T, + price: u64) { + assert!(kiosk_extension::is_installed(kiosk), EExtensionNotInstalled); + + let id = object::id(&item); + kiosk.place_and_list(cap, item, price); + + let item_price = ItemPrice { + price, + }; + + place_in_bag(kiosk, Listed { id }, item_price); + } + + + public fun get_item_price( + kiosk: &Kiosk, + item_id: ID, + ) : u64 { + let storage_ref = kiosk_extension::storage(Marketplace {}, kiosk); + let ItemPrice { price } = bag::borrow>( + storage_ref, + Listed { id: item_id }, + ); + + *price + } + + + // === Private Functions === + + fun take_from_bag( + kiosk: &mut Kiosk, + item_key: Key, + ) : ItemPrice { + let ext_storage_mut = kiosk_extension::storage_mut(Marketplace {}, kiosk); + bag::remove>( + ext_storage_mut, + item_key, + ) + } + + fun place_in_bag( + kiosk: &mut Kiosk, + item_key: Key, + item_price: ItemPrice, + ) { + let ext_storage_mut = kiosk_extension::storage_mut(Marketplace {}, kiosk); + bag::add(ext_storage_mut, item_key, item_price); + } +} \ No newline at end of file diff --git a/docs/examples/move/nft_marketplace/sources/rental_extension.move b/docs/examples/move/nft_marketplace/sources/rental_extension.move new file mode 100644 index 00000000000..e971e79b210 --- /dev/null +++ b/docs/examples/move/nft_marketplace/sources/rental_extension.move @@ -0,0 +1,430 @@ +/// NFT renting is a mechanism that allows individuals without ownership or possession of a specific +/// NFT to temporarily utilize or experience it. +/// The rental_extension module provides an API that facilitates lending or borrowing through the following operations: +/// - List for renting +/// - Delist from renting +/// - Rent +/// - Borrow by reference and borrow by value +/// - Reclaim for the lender +module nft_marketplace::rental_extension { + + // iota imports + use iota::{ + kiosk::{Kiosk, KioskOwnerCap, purchase}, + kiosk_extension, + bag, + transfer_policy::{Self, TransferPolicy, TransferPolicyCap, has_rule}, + clock::Clock, + coin::{Self, Coin}, + balance::{Self, Balance}, + iota::IOTA, + package::Publisher + }; + + // rules imports + use kiosk::kiosk_lock_rule::Rule as LockRule; + + // === Errors === + const EExtensionNotInstalled: u64 = 0; + const ENotOwner: u64 = 1; + const ENotEnoughCoins: u64 = 2; + const EInvalidKiosk: u64 = 3; + const ERentingPeriodNotOver: u64 = 4; + const ETotalPriceOverflow: u64 = 6; + + // === Constants === + const ALLOW_PLACE_AND_LOCK: u128 = 11; + const SECONDS_IN_A_DAY: u64 = 86400; + const MAX_BASIS_POINTS: u16 = 10_000; + const MAX_VALUE_U64: u64 = 0xff_ff_ff_ff__ff_ff_ff_ff; + + // === Structs === + + /// Extension Key for Kiosk Marketplace extension. + public struct Rental has drop {} + + /// Struct representing a rented item. + /// Used as a key for the Rentable that's placed in the Extension's Bag. + public struct Rented has store, copy, drop { id: ID } + + /// Struct representing a listed item. + /// Used as a key for the Rentable that's placed in the Extension's Bag. + public struct Listed has store, copy, drop { id: ID } + + /// Promise struct for borrowing by value. + public struct Promise { + item: Rented, + duration: u64, + start_date: u64, + price_per_day: u64, + renter_kiosk: ID, + borrower_kiosk: ID, + } + + /// A wrapper object that holds an asset that is being rented. + /// Contains information relevant to the rental period, cost and renter. + public struct Rentable has store { + object: T, + /// Total amount of time offered for renting in days. + duration: u64, + /// Initially undefined, is updated once someone rents it. + start_date: Option, + price_per_day: u64, + /// The kiosk id that the object was taken from. + kiosk_id: ID, + } + + /// A shared object that should be minted by every creator. + /// Defines the royalties the creator will receive from each rent invocation. + public struct RentalPolicy has key, store { + id: UID, + balance: Balance, + /// Note: Move does not support float numbers. + /// + /// If you need to represent a float, you need to determine the desired + /// precision and use a larger integer representation. + /// + /// For example, fpercentages can be represented using basis points: + /// 10000 basis points represent 100% and 100 basis points represent 1%. + amount_bp: u64 + } + + /// A shared object that should be minted by every creator. + /// Even for creators that do not wish to enforce royalties. Provides authorized access to an + /// empty TransferPolicy. + public struct ProtectedTP has key, store { + id: UID, + transfer_policy: TransferPolicy, + policy_cap: TransferPolicyCap + } + + // === Public Functions === + + /// Enables someone to install the Rental extension in their Kiosk. + public fun install( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + ctx: &mut TxContext, + ) { + kiosk_extension::add(Rental {}, kiosk, cap, ALLOW_PLACE_AND_LOCK, ctx); + } + + /// Remove the extension from the Kiosk. Can only be performed by the owner, + /// The extension storage must be empty for the transaction to succeed. + public fun remove(kiosk: &mut Kiosk, cap: &KioskOwnerCap, _ctx: &mut TxContext) { + kiosk_extension::remove(kiosk, cap); + } + + /// Mints and shares a ProtectedTP & a RentalPolicy object for type T. + /// Can only be performed by the publisher of type T. + public fun setup_renting(publisher: &Publisher, amount_bp: u64, ctx: &mut TxContext) { + // Creates an empty TP and shares a ProtectedTP object. + // This can be used to bypass the lock rule under specific conditions. + // Storing inside the cap the ProtectedTP with no way to access it + // as we do not want to modify this policy + let (transfer_policy, policy_cap) = transfer_policy::new(publisher, ctx); + + let protected_tp = ProtectedTP { + id: object::new(ctx), + transfer_policy, + policy_cap, + }; + + let rental_policy = RentalPolicy { + id: object::new(ctx), + balance: balance::zero(), + amount_bp, + }; + + transfer::share_object(protected_tp); + transfer::share_object(rental_policy); + } + + /// Enables someone to list an asset within the Marketplace extension's Bag, + /// creating a Bag entry with the asset's ID as the key and a Rentable wrapper object as the value. + /// Requires the existance of a ProtectedTP which can only be created by the creator of type T. + /// Assumes item is already placed (& optionally locked) in a Kiosk. + public fun list( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + protected_tp: &ProtectedTP, + item_id: ID, + duration: u64, + price_per_day: u64, + ctx: &mut TxContext, + ) { + assert!(kiosk_extension::is_installed(kiosk), EExtensionNotInstalled); + + let max_price_per_day = MAX_VALUE_U64 / duration; + assert!(price_per_day <= max_price_per_day, ETotalPriceOverflow); + kiosk.set_owner(cap, ctx); + kiosk.list(cap, item_id, 0); + + let coin = coin::zero(ctx); + let (object, request) = kiosk.purchase(item_id, coin); + + let (_item, _paid, _from) = protected_tp.transfer_policy.confirm_request(request); + + let rentable = Rentable { + object, + duration, + start_date: option::none(), + price_per_day, + kiosk_id: object::id(kiosk), + }; + + place_in_bag(kiosk, Listed { id: item_id }, rentable); + } + + /// Allows the renter to delist an item, that is not currently being rented. + /// Places (or locks, if a lock rule is present) the object back to owner's Kiosk. + /// Creators should mint an empty TransferPolicy even if they don't want to apply any royalties. + /// If they wish at some point to enforce royalties, they can update the existing TransferPolicy. + public fun delist( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + transfer_policy: &TransferPolicy, + item_id: ID, + _ctx: &mut TxContext, + ) { + assert!(kiosk_extension::is_installed(kiosk), EExtensionNotInstalled); + assert!(kiosk.has_access(cap), ENotOwner); + + let rentable = take_from_bag(kiosk, Listed { id: item_id }); + + let Rentable { + object, + duration: _, + start_date: _, + price_per_day: _, + kiosk_id: _, + } = rentable; + + if (has_rule(transfer_policy)) { + kiosk.lock(cap, transfer_policy, object); + } else { + kiosk.place(cap, object); + }; + } + + /// This enables individuals to rent a listed Rentable. + /// + /// It permits anyone to borrow an item on behalf of another user, provided they have the + /// Marketplace extension installed. + /// + /// The Rental Policy defines the portion of the coin that will be retained as fees and added to + /// the Rental Policy's balance. + public fun rent( + renter_kiosk: &mut Kiosk, + borrower_kiosk: &mut Kiosk, + rental_policy: &mut RentalPolicy, + item_id: ID, + mut coin: Coin, + clock: &Clock, + ctx: &mut TxContext, + ) { + assert!(kiosk_extension::is_installed(borrower_kiosk), EExtensionNotInstalled); + + let mut rentable = take_from_bag(renter_kiosk, Listed { id: item_id }); + + let total_price = rentable.price_per_day * rentable.duration; + + let coin_value = coin.value(); + assert!(coin_value == total_price, ENotEnoughCoins); + + let fees_amount = calculate_fees_amount(coin_value as u128, rental_policy.amount_bp as u128); + + let fees = coin.split(fees_amount as u64, ctx); + + coin::put(&mut rental_policy.balance, fees); + transfer::public_transfer(coin, renter_kiosk.owner()); + rentable.start_date.fill(clock.timestamp_ms()); + + place_in_bag(borrower_kiosk, Rented { id: item_id }, rentable); + } + + /// Enables the borrower to acquire the Rentable by reference from their bag. + public fun borrow( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + item_id: ID, + _ctx: &mut TxContext, + ): &T { + assert!(kiosk.has_access(cap), ENotOwner); + let ext_storage_mut = kiosk_extension::storage_mut(Rental {}, kiosk); + let rentable: &Rentable = &ext_storage_mut[Rented { id: item_id }]; + &rentable.object + } + + /// Enables the borrower to temporarily acquire the Rentable with an agreement or promise to + /// return it. + /// + /// All the information about the Rentable is stored within the promise, facilitating the + /// reconstruction of the Rentable when the object is returned. + public fun borrow_val( + kiosk: &mut Kiosk, + cap: &KioskOwnerCap, + item_id: ID, + _ctx: &mut TxContext, + ): (T, Promise) { + assert!(kiosk.has_access(cap), ENotOwner); + let borrower_kiosk = object::id(kiosk); + + let rentable = take_from_bag(kiosk, Rented { id: item_id }); + + let promise = Promise { + item: Rented { id: item_id }, + duration: rentable.duration, + start_date: *option::borrow(&rentable.start_date), + price_per_day: rentable.price_per_day, + renter_kiosk: rentable.kiosk_id, + borrower_kiosk + }; + + let Rentable { + object, + duration: _, + start_date: _, + price_per_day: _, + kiosk_id: _, + } = rentable; + + (object, promise) + } + + /// Enables the borrower to return the borrowed item. + public fun return_val( + kiosk: &mut Kiosk, + object: T, + promise: Promise, + _ctx: &mut TxContext, + ) { + assert!(kiosk_extension::is_installed(kiosk), EExtensionNotInstalled); + + let Promise { + item, + duration, + start_date, + price_per_day, + renter_kiosk, + borrower_kiosk, + } = promise; + + let kiosk_id = object::id(kiosk); + assert!(kiosk_id == borrower_kiosk, EInvalidKiosk); + + let rentable = Rentable { + object, + duration, + start_date: option::some(start_date), + price_per_day, + kiosk_id: renter_kiosk, + }; + + place_in_bag(kiosk, item, rentable); + } + + /// Enables the owner to reclaim their asset once the rental period has concluded. + public fun reclaim( + renter_kiosk: &mut Kiosk, + borrower_kiosk: &mut Kiosk, + transfer_policy: &TransferPolicy, + clock: &Clock, + item_id: ID, + _ctx: &mut TxContext, + ) { + assert!(kiosk_extension::is_installed(renter_kiosk), EExtensionNotInstalled); + + let rentable = take_from_bag(borrower_kiosk, Rented { id: item_id }); + + let Rentable { + object, + duration, + start_date, + price_per_day: _, + kiosk_id, + } = rentable; + + assert!(object::id(renter_kiosk) == kiosk_id, EInvalidKiosk); + + let start_date_ms = *option::borrow(&start_date); + let current_timestamp = clock.timestamp_ms(); + let final_timestamp = start_date_ms + duration * SECONDS_IN_A_DAY; + assert!(current_timestamp > final_timestamp, ERentingPeriodNotOver); + + if (transfer_policy.has_rule()) { + kiosk_extension::lock( + Rental {}, + renter_kiosk, + object, + transfer_policy, + ); + } else { + kiosk_extension::place( + Rental {}, + renter_kiosk, + object, + transfer_policy, + ); + }; + } + + // === Private Functions === + + // Calculate fees_amount using the given basis points amount (percentage), ensuring the + // result fits into a 64-bit unsigned integer. + fun calculate_fees_amount(coin_value: u128, rental_amount_bp: u128): u128 { + + let mut fees_amount = coin_value as u128; + fees_amount = fees_amount * (rental_amount_bp as u128); + fees_amount = fees_amount / (MAX_BASIS_POINTS as u128); + + fees_amount + } + + fun take_from_bag( + kiosk: &mut Kiosk, + item: Key, + ) : Rentable { + let ext_storage_mut = kiosk_extension::storage_mut(Rental {}, kiosk); + bag::remove>( + ext_storage_mut, + item, + ) + } + + fun place_in_bag( + kiosk: &mut Kiosk, + item: Key, + rentable: Rentable, + ) { + let ext_storage_mut = kiosk_extension::storage_mut(Rental {}, kiosk); + bag::add(ext_storage_mut, item, rentable); + } + + // === Test Functions === + + #[test_only] + // public fun test_take_from_bag(kiosk: &mut Kiosk, item_id: ID) { + public fun test_take_from_bag( + kiosk: &mut Kiosk, + item: Key, + ) { + let rentable = take_from_bag(kiosk, item); + + let Rentable { + object, + duration: _, + start_date: _, + price_per_day: _, + kiosk_id: _ + } = rentable; + + transfer::public_share_object(object); + } + + #[test_only] + public fun create_listed(id: ID) : Listed { + Listed { id } + } +} diff --git a/docs/examples/move/nft_marketplace/tests/marketplace_extension_tests.move b/docs/examples/move/nft_marketplace/tests/marketplace_extension_tests.move new file mode 100644 index 00000000000..d0e97eb016a --- /dev/null +++ b/docs/examples/move/nft_marketplace/tests/marketplace_extension_tests.move @@ -0,0 +1,223 @@ + +#[test_only] +module nft_marketplace::marketplace_extension_tests { + + use nft_marketplace::test_utils::{create_kiosk, create_transfer_policy}; + use kiosk::royalty_rule as royalty_rule; + use nft_marketplace::marketplace_extension::Self; + use iota::{ + iota::IOTA, + coin::Coin, + kiosk::Kiosk, + kiosk_test_utils, + package::Self, + test_scenario::{Self as ts, Scenario}, + transfer_policy::{TransferPolicy, TransferPolicyCap} + }; + + const CREATOR: address = @0xCCCC; + const SELLER: address = @0xAAAA; + const BUYER: address = @0xBBBB; + + public struct T has key, store { id: UID } + public struct WITNESS has drop {} + + + // ==================== Happy path scenarios ==================== + + #[test] + fun test_buy_item_without_royalties() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + + create_transfer_policy( CREATOR, &publisher, ts.ctx()); + install_ext(&mut ts, SELLER, seller_kiosk_id); + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + let payment = kiosk_test_utils::get_iota(item_price, ts.ctx()); + buy(&mut ts, BUYER, seller_kiosk_id, item_id, payment); + + publisher.burn_publisher(); + ts.end(); + } + + #[test] + fun test_buy_item_with_royalties() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + let royalty_amount_bp = 5000; + let royalty_min_amount = 2000; + create_transfer_policy( CREATOR, &publisher, ts.ctx()); + add_royalty_rule(&mut ts, CREATOR, royalty_amount_bp, royalty_min_amount); + install_ext(&mut ts, SELLER, seller_kiosk_id); + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + let mut payment = kiosk_test_utils::get_iota(item_price, ts.ctx()); + let royalty_amount_to_pay = get_royalty_fee_amount(&ts, item_price); + let royalties_coin = kiosk_test_utils::get_iota(royalty_amount_to_pay, ts.ctx()); + payment.join(royalties_coin); + buy(&mut ts, BUYER, seller_kiosk_id, item_id, payment); + + publisher.burn_publisher(); + ts.end(); + } + + #[test] + fun test_get_item_price() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + + install_ext(&mut ts, SELLER, seller_kiosk_id); + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + ts.next_tx(SELLER); + let kiosk: Kiosk = ts.take_shared_by_id(seller_kiosk_id); + let storage_item_price = marketplace_extension::get_item_price(&kiosk, item_id); + + assert!(storage_item_price == item_price); + + ts::return_shared(kiosk); + ts.end(); + } + + // ==================== Negative scenarios ==================== + + #[test] + #[expected_failure(abort_code = marketplace_extension::EWrongPaymentRoyalties)] + fun test_buy_item_with_royalties_wrong_royalties_amount() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + let royalty_amount_bp = 5000; + let royalty_min_amount = 2000; + create_transfer_policy( CREATOR, &publisher, ts.ctx()); + add_royalty_rule(&mut ts, CREATOR, royalty_amount_bp, royalty_min_amount); + install_ext(&mut ts, SELLER, seller_kiosk_id); + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + let mut payment = kiosk_test_utils::get_iota(item_price, ts.ctx()); + let royalty_amount_to_pay = get_royalty_fee_amount(&ts, 1000); + let royalties_coin = kiosk_test_utils::get_iota(royalty_amount_to_pay, ts.ctx()); + payment.join(royalties_coin); + buy(&mut ts, BUYER, seller_kiosk_id, item_id, payment); + + publisher.burn_publisher(); + ts.end(); + } + + #[test] + #[expected_failure(abort_code = marketplace_extension::ENotEnoughPaymentAmount)] + fun test_buy_item_without_royalties_wrong_price() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + + create_transfer_policy( CREATOR, &publisher, ts.ctx()); + install_ext(&mut ts, SELLER, seller_kiosk_id); + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + let payment = kiosk_test_utils::get_iota(40000, ts.ctx()); + buy(&mut ts, BUYER, seller_kiosk_id, item_id, payment); + + publisher.burn_publisher(); + ts.end(); + } + + #[test] + #[expected_failure(abort_code = marketplace_extension::EExtensionNotInstalled)] + fun test_set_price_without_extension() { + let mut ts = ts::begin(SELLER); + + let item = T { id: object::new(ts.ctx()) }; + + let seller_kiosk_id = create_kiosk(SELLER, ts.ctx()); + let item_price = 50000; + + setup_price(&mut ts, SELLER, seller_kiosk_id, item, item_price); + + ts.end(); + } + // ==================== Helper methods ==================== + + + fun setup_price(ts: &mut Scenario, sender: address, seller_kiosk_id: ID, item: T, price: u64) { + ts.next_tx(sender); + let mut kiosk: Kiosk = ts.take_shared_by_id(seller_kiosk_id); + let kiosk_cap = ts.take_from_sender(); + + marketplace_extension::set_price(&mut kiosk, &kiosk_cap, item, price); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); + } + + fun install_ext(ts: &mut Scenario, sender: address, kiosk_id: ID) { + ts.next_tx(sender); + let mut kiosk: Kiosk = ts.take_shared_by_id(kiosk_id); + let kiosk_cap = ts.take_from_sender(); + + marketplace_extension::install(&mut kiosk, &kiosk_cap, ts.ctx()); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); + } + + fun buy(ts: &mut Scenario, buyer: address, seller_kiosk_id: ID, item_id: ID, payment: Coin) { + ts.next_tx(buyer); + let mut kiosk: Kiosk = ts.take_shared_by_id(seller_kiosk_id); + let mut policy: TransferPolicy = ts.take_shared(); + + let item = marketplace_extension::buy_item(&mut kiosk, &mut policy, item_id, payment, ts.ctx()); + transfer::public_transfer(item, buyer); + ts::return_shared(kiosk); + ts::return_shared(policy); + } + + fun add_royalty_rule(ts: &mut Scenario, sender: address, amount_bp: u16, min_amount: u64) { + ts.next_tx(sender); + let mut transfer_policy: TransferPolicy = ts.take_shared(); + let policy_cap: TransferPolicyCap = ts.take_from_sender(); + + marketplace_extension::setup_royalties(&mut transfer_policy, &policy_cap, amount_bp, min_amount); + + ts::return_shared(transfer_policy); + ts.return_to_sender(policy_cap); + } + + fun get_royalty_fee_amount(ts: &Scenario, price: u64): u64 { + let transfer_policy: TransferPolicy = ts.take_shared(); + let royalty_fee = royalty_rule::fee_amount(&transfer_policy, price); + ts::return_shared(transfer_policy); + royalty_fee + } +} \ No newline at end of file diff --git a/docs/examples/move/nft_marketplace/tests/rental_extension_tests.move b/docs/examples/move/nft_marketplace/tests/rental_extension_tests.move new file mode 100644 index 00000000000..8fabfd78d7d --- /dev/null +++ b/docs/examples/move/nft_marketplace/tests/rental_extension_tests.move @@ -0,0 +1,362 @@ + +#[test_only] +module nft_marketplace::rental_extension_tests { + + use kiosk::kiosk_lock_rule as lock_rule; + use nft_marketplace::test_utils::{create_kiosk, create_transfer_policy}; + use nft_marketplace::rental_extension::{Self, ProtectedTP, RentalPolicy}; + use iota::{ + clock::{Self, Clock}, + kiosk::{Kiosk, KioskOwnerCap}, + kiosk_test_utils, + package::{Self, Publisher}, + test_scenario::{Self as ts, Scenario}, + transfer_policy::{TransferPolicy, TransferPolicyCap} + }; + + const CREATOR: address = @0xCCCC; + const RENTER: address = @0xAAAA; + const BORROWER: address = @0xBBBB; + const THIEF: address = @0xDDDD; + + public struct T has key, store { id: UID } + public struct WITNESS has drop {} + + +// ==================== Happy path scenarios ==================== + + #[test] + fun test_rent_with_extension() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + setup(&mut ts, RENTER, &publisher, 50); + install_ext(&mut ts, RENTER, renter_kiosk_id); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + + clock.destroy_for_testing(); + publisher.burn_publisher(); + ts.end(); + } + + #[test] + fun test_reclaim() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let mut clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + create_transfer_policy( CREATOR, &publisher, ts.ctx()); + setup(&mut ts, RENTER, &publisher, 50); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + reclaim(&mut ts, RENTER, renter_kiosk_id, borrower_kiosk_id, item_id, 432000000, &mut clock); + + clock.destroy_for_testing(); + publisher.burn_publisher(); + ts.end(); + } + + // ==================== Negative scenarios ==================== + + #[test] + #[expected_failure(abort_code = rental_extension::EExtensionNotInstalled)] + fun test_rent_without_extension() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + setup(&mut ts, RENTER, &publisher, 50); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + abort 0xbad + } + + #[test] + #[expected_failure(abort_code = rental_extension::ENotEnoughCoins)] + fun test_rent_with_not_enough_coins() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + setup(&mut ts, RENTER, &publisher, 50); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 10, &clock); + abort 0xbad + } + + #[test] + #[expected_failure(abort_code = rental_extension::ETotalPriceOverflow)] + fun test_rent_with_overflow() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + setup(&mut ts, RENTER, &publisher, 50); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 100, 1844674407370955160); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + abort 0xbad + } + + #[test] + fun test_reclaim_locked() { + let mut ts = ts::begin(RENTER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let mut clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + + create_transfer_policy(CREATOR, &publisher, ts.ctx()); + add_lock_rule(&mut ts, CREATOR); + setup(&mut ts, RENTER, &publisher, 50); + lock_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + reclaim(&mut ts, RENTER, renter_kiosk_id, borrower_kiosk_id, item_id, 432000000, &mut clock); + + clock.destroy_for_testing(); + publisher.burn_publisher(); + ts.end(); + } + + #[test] + #[expected_failure(abort_code = rental_extension::EInvalidKiosk)] + fun test_reclaim_wrong_kiosk() { + let mut ts = ts::begin(BORROWER); + + let item = T { id: object::new(ts.ctx()) }; + let item_id = object::id(&item); + + let mut clock = clock::create_for_testing(ts.ctx()); + + let witness = WITNESS {}; + let publisher = package::test_claim(witness, ts.ctx()); + + let renter_kiosk_id = create_kiosk(RENTER, ts.ctx()); + let borrower_kiosk_id = create_kiosk(BORROWER, ts.ctx()); + let thief_kiosk_id = create_kiosk(THIEF, ts.ctx()); + + create_transfer_policy(CREATOR, &publisher, ts.ctx()); + setup(&mut ts, RENTER, &publisher, 50); + place_in_kiosk(&mut ts, RENTER, renter_kiosk_id, item); + install_ext(&mut ts, RENTER, renter_kiosk_id); + list_for_rent(&mut ts, RENTER, renter_kiosk_id, item_id, 10, 10); + install_ext(&mut ts, BORROWER, borrower_kiosk_id); + rent(&mut ts, BORROWER, renter_kiosk_id, borrower_kiosk_id, item_id, 100, &clock); + install_ext(&mut ts, THIEF, thief_kiosk_id); + reclaim(&mut ts, RENTER, thief_kiosk_id, borrower_kiosk_id, item_id, 432000000, &mut clock); + abort 0xbad + } + + // ==================== Helper methods ==================== + + fun place_in_kiosk(ts: &mut Scenario, sender: address, kiosk_id: ID, item: T) { + ts.next_tx(sender); + let mut kiosk: Kiosk = ts.take_shared_by_id(kiosk_id); + let kiosk_cap: KioskOwnerCap = ts.take_from_sender(); + + kiosk.place(&kiosk_cap, item); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); + } + + + fun list_for_rent( + ts: &mut Scenario, + sender: address, + kiosk_id: ID, + item_id: ID, + duration: u64, + price: u64, + ) { + ts.next_tx(sender); + let mut kiosk: Kiosk = ts.take_shared_by_id(kiosk_id); + let kiosk_cap: KioskOwnerCap = ts.take_from_sender(); + let protected_tp: ProtectedTP = ts.take_shared(); + + rental_extension::list( + &mut kiosk, + &kiosk_cap, + &protected_tp, + item_id, + duration, + price, + ts.ctx(), + ); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); + ts::return_shared(protected_tp); + } + + fun rent( + ts: &mut Scenario, + sender: address, + renter_kiosk_id: ID, + borrower_kiosk_id: ID, + item_id: ID, + coin_amount: u64, + clock: &Clock, + ) { + ts.next_tx(sender); + + let mut borrower_kiosk: Kiosk = ts.take_shared_by_id(borrower_kiosk_id); + let mut renter_kiosk: Kiosk = ts.take_shared_by_id(renter_kiosk_id); + let mut rental_policy: RentalPolicy = ts.take_shared(); + + let coin = kiosk_test_utils::get_iota(coin_amount, ts.ctx()); + + rental_extension::rent( + &mut renter_kiosk, + &mut borrower_kiosk, + &mut rental_policy, + item_id, + coin, + clock, + ts.ctx(), + ); + + ts::return_shared(borrower_kiosk); + ts::return_shared(renter_kiosk); + ts::return_shared(rental_policy); + } + + fun setup(ts: &mut Scenario, sender: address, publisher: &Publisher, amount_bp: u64) { + ts.next_tx(sender); + rental_extension::setup_renting(publisher, amount_bp, ts.ctx()); + } + + fun reclaim( + ts: &mut Scenario, + sender: address, + renter_kiosk_id: ID, + borrower_kiosk_id: ID, + item_id: ID, + tick: u64, + clock: &mut Clock, + ) { + ts.next_tx(sender); + let mut borrower_kiosk: Kiosk = ts.take_shared_by_id(borrower_kiosk_id); + let mut renter_kiosk: Kiosk = ts.take_shared_by_id(renter_kiosk_id); + let policy: TransferPolicy = ts.take_shared(); + + clock.increment_for_testing(tick); + rental_extension::reclaim( + &mut renter_kiosk, + &mut borrower_kiosk, + &policy, + clock, + item_id, + ts.ctx(), + ); + + ts::return_shared(policy); + ts::return_shared(borrower_kiosk); + ts::return_shared(renter_kiosk); + } + + fun add_lock_rule(ts: &mut Scenario, sender: address) { + ts.next_tx(sender); + let mut transfer_policy: TransferPolicy = ts.take_shared(); + let policy_cap: TransferPolicyCap = ts.take_from_sender(); + + lock_rule::add(&mut transfer_policy, &policy_cap); + + ts::return_shared(transfer_policy); + ts.return_to_sender(policy_cap); + } + + fun lock_in_kiosk(ts: &mut Scenario, sender: address, kiosk_id: ID, item: T) { + ts.next_tx(sender); + + let mut kiosk: Kiosk = ts.take_shared_by_id(kiosk_id); + let kiosk_cap: KioskOwnerCap = ts.take_from_sender(); + let transfer_policy: TransferPolicy = ts.take_shared(); + + kiosk.lock(&kiosk_cap, &transfer_policy, item); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); + ts::return_shared(transfer_policy); + } + + fun install_ext(ts: &mut Scenario, sender: address, kiosk_id: ID) { + ts.next_tx(sender); + let mut kiosk: Kiosk = ts.take_shared_by_id(kiosk_id); + let kiosk_cap = ts.take_from_sender(); + + rental_extension::install(&mut kiosk, &kiosk_cap, ts.ctx()); + + ts::return_shared(kiosk); + ts.return_to_sender(kiosk_cap); +} +} diff --git a/docs/examples/move/nft_marketplace/tests/utils.move b/docs/examples/move/nft_marketplace/tests/utils.move new file mode 100644 index 00000000000..01498370bcc --- /dev/null +++ b/docs/examples/move/nft_marketplace/tests/utils.move @@ -0,0 +1,24 @@ +#[test_only] +module nft_marketplace::test_utils { + use iota::{ + kiosk_test_utils, + package::Publisher, + transfer_policy::Self + }; + + + public fun create_transfer_policy(sender: address, publisher: &Publisher, ctx: &mut TxContext) { + let (transfer_policy, policy_cap) = transfer_policy::new(publisher, ctx); + transfer::public_share_object(transfer_policy); + transfer::public_transfer(policy_cap, sender); + } + + public fun create_kiosk(sender: address, ctx: &mut TxContext): ID { + let (kiosk, kiosk_cap) = kiosk_test_utils::get_kiosk(ctx); + let kiosk_id = object::id(&kiosk); + transfer::public_share_object(kiosk); + transfer::public_transfer(kiosk_cap, sender); + + kiosk_id +} +} \ No newline at end of file