FIFA 最近的一項聲明席卷了區塊鏈社區：它與區塊鏈創新者 Algorand 建立了合作關系。區塊鏈協議 Algorand 旨在幫助 FIFA 制定“數字資產戰略”并提供官方“錢包解決方案”。

這不是 Algorand 第一次與大型項目合作。此前，馬紹爾群島聯邦政府宣布與 Algorand 合作創建其第一個國家貨幣 SOV，這也是世界上第一個國家貨幣。同樣，還有其他幾項合作公告，例如 FIDE Grand Prix 系列（世界國際象棋錦標賽）、SIAE（意大利集體版權管理公司）、Republic（投資平臺和技術服務）等等。所有這些合作伙伴關系的公告證明，Algorand 已成為區塊鏈領域可靠的區塊鏈生態系統。

Algorand 由 Silvio Micali 領導的團隊于 2017 年推出，他是圖靈獎獲得者，因其在 2012 年對密碼學的貢獻而獲得認可。他是可驗證隨機證明、零知識證明等各種密碼技術的共同創造者。

Micali 認為區塊鏈協議可以同時實現去中心化、可擴展性和安全性，而不會犧牲其中任何一個，正如以太坊創始人 Vitalik Buterin 在 2016 年提出的那樣。這激發了 Micali 創建 Algorand，這是一個無需許可的區塊鏈，旨在解決多年來讓區塊鏈社區困惑的區塊鏈三難困境。它是一個面向智能合約的平臺，無需分叉即可提供即時交易最終確定性。Algo 是 Algorand 的原生加密貨幣，用于質押、治理和交易。

本文提供了對 Algorand 的深入了解，并詳細說明了在 Algorand 上開發 NFT 市場的步驟。

• 關于 Algorand

• 如何在 Algorand 上開發 NFT 市場？

• 第 1 步：定義有狀態智能合約接口

• 第 2 步：實施有狀態的智能合約

• 第3步：實現無狀態智能合約

• 第4步：通訊服務

• 第 5 步：部署 Algorand 測試網

關于 Algorand

Algorand 是一個區塊鏈生態系統，它在稱為純權益證明的獨特共識機制上運行，使其能夠處理多達 1000 筆交易并提供即時交易最終確定性而無需分叉。Pure Proof-of-Stake 有兩種類型的節點：參與者節點和中繼節點。顧名思義，參與者節點參與共識，而中繼節點則支持參與者節點之間的交互。在 Pure Proof-of-Stake 中，隨機選擇 1000 個參與者節點來生成一個塊，從中隨機選擇一個節點將其塊添加到 Algorand 區塊鏈中。被選中取決于參與者節點質押了多少 Algo。質押的 Algo 數量越多，被選中的機會就越大。

Algorand 網絡包含三個關鍵功能：

• Algorand 標準資產——它是第 1 層功能，允許用戶代表 Algorand 區塊鏈上的任何資產，同時受益于 Algo 的安全性、兼容性、速度和易用性。

• Algorand Atomic Transfer –這些是不可約的批量交易，可保證同時執行任何資產的多個交易。

• 智能合約——Algorand 提供直接構建在第 1 層區塊鏈上的高度可定制的智能合約。

Algorand 智能合約可分為以下幾類：

• 有狀態的智能合約：它們可以存儲和更新鏈上值并實現應用程序邏輯。

• 無狀態智能合約：它們經常用于批準支出或資產轉移，并且它們管理來自單個賬戶的所有交易。

現在我們對 Algorand 基礎設施有了一個概念，讓我們來看看 Algorand NFT 市場的開發。

如何在 Algorand 上開發 NFT 市場？

在您的 Python 環境中安裝下面提到的軟件包：

• PyYAML

• py_algorand_sdk

• pyteal

• 流線型

此外，創建一個“config.yml”文件，您必須在其中添加憑據以連接 Algorand 客戶端。

帳戶：

帳戶_1：

地址：PUBLIC_KEY_VALUE

助記符：MNEMONIC_WORDS

private_key：PRIVATE_KEY_VALUE

帳戶_2：

地址：PUBLIC_KEY_VALUE

助記符：MNEMONIC_WORDS

private_key：PRIVATE_KEY_VALUE

帳戶_3：

地址：PUBLIC_KEY_VALUE

助記符：MNEMONIC_WORDS

private_key：PRIVATE_KEY_VALUE

總數：3

客戶憑證：

地址：ADDRESS_VALUE

令牌：TOKEN_VALUE

第 1 步：定義有狀態智能合約接口

有狀態的智能合約代表一個存在于 Algorand 網絡上的應用程序。應用程序調用事務促進了用戶和應用程序之間的交互。目前，交易是由用戶界面應用程序、移動應用程序、Web 應用程序或 CLI 通過網絡創建和發送的。

首先，概述一個涉及所有必需方法的“NFTMarketplaceInterface” 。這些方法描述了外部應用程序和有狀態智能合約之間的交互。

NFTMarketplaceInterface類（ABC ）：

   @抽象方法

def initialize_escrow ( self, escrow_address ) ：

       經過

   @抽象方法

def make_sell_offer （自我，sell_price ）：

       經過

   @抽象方法

def購買（自我）：

       經過

   @抽象方法

def stop_sell_offer （自我）：

       經過

一個抽象的python類用于表示接口。該接口中描述的所有方法都必須由想要遵守它的智能合約實現。需要注意的是，這個接口可以被多個智能合約使用，每個智能合約可以有不同的實現邏輯。盡管有單獨的實現邏輯，但外部通信不會改變。

在“NFTMarketplaceInterface”中，定義了四個方法：

• “initialize_escrow(escrow_address)”——初始化用于傳輸 NFT 的托管地址。

• “make_sell_offer(sell_price)”——它以特定的“sell_price”為 NFT 生成賣出報價。

• “buy()”——用戶從賣出報價中購買 NFT

• “stop_sell_offer()”——取消當前的 NFT 賣出報價。

第 2 步：實施有狀態的智能合約

接下來，我們必須構建一個名為“NFTMarketplaceASC1”的具體類，它執行“NFTMarketplaceInterface”。此類將存儲有狀態智能合約的所有 PyTeal 邏輯。

定義常量

每個有狀態的智能合約都可以具有全局和本地狀態，形成應用程序狀態數據。鍵值對用于表示這些狀態。將鍵定義為常量是一種很好的做法，它可以使代碼更易于閱讀且不易出錯。此外，模式還指定鍵值對中使用的整數和字節數。全局狀態有一個全局模式，本地狀態有一個本地模式。

NFTMarketplaceASC1類（NFTMarketplaceInterface ）：

類變量：

       escrow_address =字節（“ESCROW_ADDRESS” ）

       asa_id =字節（“ASA_ID” ）

       asa_price =字節（“ASA_PRICE” ）

       asa_owner =字節（“ASA_OWNER” ）

       app_state =字節（“APP_STATE” ）

       app_admin =字節（“APP_ADMIN” ）

類AppMethods：

       initialize_escrow = "初始化托管"

       make_sell_offer = "makeSellOffer"

       買= “買”

       stop_sell_offer = "stopSellOffer"

類應用程序狀態：

       not_initialized = Int ( 0 )

       活躍 = Int ( 1 )

       sell_in_progress = Int ( 2 )

   @財產

def global_schema ( self ) :

返回algosdk。未來。交易。StateSchema ( num_uints= 3 ,

                                                     num_byte_slices= 3 )

   @財產

def local_schema （自我）：

返回algosdk。未來。交易。StateSchema ( num_uints= 0 ,

                                                     num_byte_slices= 0 )

我們將常量分解為不同的類，以使代碼更具可讀性和可維護性：

• “變量”——指定智能合約全局變量的鍵。這些變量代表應用程序的全局狀態。

• “AppMethods”——指定允許智能合約與外部應用程序通信的所有方法。此類中的每個常量都必須映射到特定接口中定義的不同方法。

變量

合約由六個全局變量、三個整數和三個字節組成。

• “escrow_address”——包括負責 Algorand 標準資產（ASA）轉移的無狀態智能合約的地址，即 NFT。

• “asa_id”——這是 NFT 的唯一標識符。智能合約負責買賣該id對應的NFT。

• “asa_price”——當賣出報價有效時，這是 NFT 的價格。

• “asa_owner”——包含 NFT 的當前所有者地址。只有這個地址才能對 NFT 發出賣出要約。

• “app_admin” -它包含管理員的地址。只有這個地址才能通過調用“initialize_escrow”方法設置“escrow_address”。

• “app_state” –它代表 AppState 類的潛在應用程序狀態之一。

  以下是三種可能的結果：

• “not_initialized”——智能合約在網絡上啟動，但托管尚未初始化。當合約處于這種狀態時，只能使用“initialize_escrow”方法。

• “活躍”——合約已鏈接到“asa_owner”和 NFT。但是，NFT 仍未出售，表明所有者尚未提供出售。

• “ sell_in_progress” – NFT 已被所有者出售。當應用程序處于此狀態時，買家可以使用“購買”方法購買 NFT。

應用方法

“ NFTMarketplaceInterface”有四種方法，由有狀態智能合約實現。結果，創建了一個“AppMethods”類，它唯一地標識了這些方法：

• “initialize_escrow”——配置智能合約的“escrow_address”。
  按照邏輯，只有“app_admin”地址的應用調用才能調用該方法。此外，“escrow_address”只能初始化一次。

• “make_sell_offer”——要以“asa_price”微算法的固定價格出售 NFT ， “asa_owner”地址可以使用此方法。

• “購買”——一旦 NFT 發售，購買者就可以使用這種方法購買 NFT。

• “stop_sell _offer”—— “asa_owner”可以使用此方法結束 NFT 當前的銷售報價。

應用程序的初始化

我們需要三個必需的參數來在網絡上部署應用程序：

• 當前擁有 NFT 的地址

• 在應用程序中具有管理員權限的地址

• NFT 的 ID

“ asa_owner”和“app_admin”作為應用程序參數發送，而“asa_id”傳輸到“ApplicationCreateTxn”的“foreign_assets”字段。

def app_initialization （自我）：

返回序列（[

斷言（Txn.application_args.length （）== Int （2 ）），_

        應用程序。globalPut ( self.Variables.app_state , self.AppState.not_initialized ) , _ _ _ _ _

        應用程序。globalPut ( self.Variables.asa_id , Txn.assets [ 0 ] ) , _ _

        應用程序。globalPut ( self.Variables.asa_owner , Txn.application_args [ 0 ] ) , _ _

        應用程序。globalPut ( self.Variables.app_admin , Txn.application_args [ 1 ] ) , _ _

返回( Int ( 1 ))

])

初始化托管

應用部署成功后，管理員必須首先調用“initialize_escrow”方法設置負責發送NFT的無狀態合約。我們通過將無狀態智能合約的地址作為 NFT 的回撥地址來實現這一點。

我們希望確保在與此方法交互時，NFT 的所有屬性都符合預期。

• NFT 不應有管理地址。有了這個條件，我們就排除了修改 NFT 的回撥地址的選項。因為我們在有狀態的智能合約中使用和存儲回撥地址，所以我們希望它是一致的。

• 我們檢查 NFT 的回撥地址是否與我們作為參數提供的托管地址相同。

• NFT 應該被凍結，否則 NFT 可能會被發送到任何地址，而“asa_owner”狀態變量保持不變。

def initialize_escrow ( self, escrow_address ) ：

       curr_escrow_address = 應用程序。globalGetEx ( Int ( 0 ) , self. Variables . escrow_address )

       資產托管=資產參數?；負埽═xn.assets [ 0 ] ）

       manager_address = AssetParam。經理（Txn.資產[ 0 ]）

       freeze_address = AssetParam。凍結（Txn.assets [ 0 ] ）

       保留地址 = 資產參數。儲備（Txn.資產[ 0 ]）

       default_frozen = AssetParam。defaultFrozen ( Txn.assets [ 0 ] )

返回序列（[

           curr_escrow_address,

斷言（curr_escrow_address.hasValue （）== Int （0 ）），

斷言（App.globalGet （self.Variables.app_admin ）== Txn.sender （）），_ _

斷言( Global.group_size ( ) == Int ( 1 )) ,

           資產托管，

           經理地址，

           凍結地址，

           保留地址，

           默認凍結，

斷言（Txn.assets [ 0 ] == App.globalGet （self.Variables.asa_id ）），_ _ _

斷言（asset_escrow.value ( ) == Txn.application_args [ 1 ] ），

斷言( default_frozen.value ( )) ,

斷言( manager_address.value () == Global.zero_address ( )) ,

斷言( freeze_address.value () == Global.zero_address ( )) ,

斷言( reserve_address.value () == Global.zero_address ( )) ,

           應用程序。globalPut （自我。變量。escrow_address ，escrow_address ），

           應用程序。globalPut ( self.Variables.app_state , self.AppState.active ) , _ _ _ _ _

返回( Int ( 1 ))

])

管理員成功初始化托管后，應用程序切換到“AppState.active”狀態?，F在將允許“asa_owner”出價出售 NFT。

提出購買報價。

NFT 通過賣出報價出售，應用程序只能由 NFT 所有者訪問以發起賣出報價。方法名稱和 NFT 價格作為參數包含在應用程序調用事務中。此應用程序的內部狀態將通過此應用程序調用從“AppState.active”更改為“AppState. sell_in_progress” 。

def make_sell_offer （自我，sell_price ）：

       valid_number_of_transactions = 全球。group_size () ==整數( 1 )

app_is_active        =或( App.globalGet ( self.Variables.app_state ) == self.AppState.active , _ _ _ _ _

                          應用程序。globalGet ( self.Variables.app_state ) == self . _ 應用狀態。銷售進度）

       有效賣家 = Txn。發件人（）==應用程序。globalGet （自我。變量。asa_owner ）

       valid_number_of_arguments = Txn。應用程序參數。長度() ==整數( 2 )

       can_sell =和( valid_number_of_transactions,

                      app_is_active,

                      有效賣家，

                      valid_number_of_arguments ）

       update_state =序列（[

           應用程序。globalPut ( self. Variables . asa_price , Btoi ( sell_price )) ,

           應用程序。globalPut ( self.Variables.app_state , self.AppState.selling_in_progress ) , _ _ _ _ _

返回( Int ( 1 ))

])

返回If ( can_sell ) 。然后（更新狀態）。否則（返回（Int （0 ）））

買

該應用程序的“購買”功能是最難使用的。這部分代碼由應用程序調用事務執行，該事務被組合成具有三個事務的原子傳輸：

1. 應用程序調用事務執行包含在“購買”函數中的 PyTeal 代碼。在那里，我們驗證應用程序是否處于“AppState. sell_in _progress”狀態，“asa_owner”接收“asa_price”算法，而“asa_buyer”接收 NFT。

2. 向 NFT 供應商支付正確數量的算法的支付交易。

3. NFT 通過原子轉移交易從當前所有者轉移到新所有者。前兩個原子轉移交易的發送者現在是新的所有者。

def購買（自我）：

       valid_number_of_transactions = 全球。group_size () == Int ( 3 )

       asa_is_on_sale = 應用程序。globalGet ( self.Variables.app_state ) == self . _ 應用狀態。銷售進度

       valid_payment_to_seller =和(

           GTXN [ 1 ] 。type_enum () == TxnType。付款，

           GTXN [ 1 ] 。接收器() == 應用程序。globalGet ( self.Variables.asa_owner ) , #正確的接收者

           GTXN [ 1 ] 。金額（）==應用程序。globalGet ( self.Variables.asa_price ) , #正確的金額

           GTXN [ 1 ] 。發件人() == Gtxn [ 0 ] 。sender () , # 相等的前兩筆交易的發送者，也就是買家

           GTXN [ 1 ] 。發件人() == Gtxn [ 2 ] 。asset_receiver () # NFT 的正確接收者

)

       valid_asa_transfer_from_escrow_to_buyer =和（

           GTXN [ 2 ] 。type_enum () == TxnType。資產轉移，

           GTXN [ 2 ] 。發件人（）==應用程序。globalGet ( self.Variables.escrow_address ) , _ _ _

           GTXN [ 2 ] 。xfer_asset () == 應用程序。globalGet （自我。變量。asa_id ），

           GTXN [ 2 ] 。asset_amount () ==整數( 1 )

)

       can_buy =和( valid_number_of_transactions,

                     asa_is_on_sale,

                     valid_payment_to_seller,

                     valid_asa_transfer_from_escrow_to_buyer ）

       update_state =序列（[

           應用程序。globalPut ( self. Variables . asa_owner , Gtxn [ 0 ] . sender ()) , # 更新 ASA 的所有者。

           應用程序。globalPut ( self.Variables.app_state , self.AppState.active ) , #更新應用狀態_ _

返回( Int ( 1 ))

])

返回If ( can_buy ) 。然后（更新狀態）。否則（返回（Int （0 ）））

提出停止銷售

我們希望添加取消銷售訂單的功能作為應用程序的最終功能。如果“asa_owner”想要停止出售 NFT，他們可以通過實現“stop_ sell_offer”方法的應用程序調用交易來實現。這是一個相當簡單的函數，只有當應用程序的發送者是 NFT 所有者時，應用程序的內部狀態才會從“AppState . sell_in_progress”更新為“AppState.active” 。

def stop_sell_offer （自我）：

       valid_number_of_transactions = 全球。group_size () ==整數( 1 )

       有效調用者 = Txn。發件人（）==應用程序。globalGet （自我。變量。asa_owner ）

       app_is_initialized = 應用程序。globalGet （自我。變量。app_state ）！=自我。應用狀態。未初始化

       can_stop_sales =和( valid_number_of_transactions,

                              有效調用者，

                              app_is_initialized )

       update_state =序列（[

           應用程序。globalPut ( self.Variables.app_state , self.AppState.active ) , _ _ _ _ _

返回( Int ( 1 ))

])

返回If ( can_stop_sales ) 。然后（更新狀態）。否則（返回（Int （0 ）））

第三步：實現無狀態智能合約

如前所述，我們將采用無狀態智能合約作為 NFT 的回撥地址。一旦評估了合約中的代碼，我們就可以將 NFT 從一個賬戶轉移到另一個賬戶。

由于有狀態智能合約包含 NFTMarketplace 應用程序的大部分功能，因此托管合約必須滿足以下要求：

• 合約簽署 AssetTransfer 交易，這是原子轉移的一部分。將 NFT 從一個地址轉移到另一個地址時，唯一的方法是使用應用程序的“購買”方法。

• 我們需要仔細檢查原子傳輸的第一個事務是否調用了正確的應用程序。在編譯托管合約中的代碼時，我們將來自有狀態智能合約的 id 作為“app_id”傳遞。

• 使用“asa_id”參數，我們檢查是否傳輸了正確的 NFT。每個 NFT 的托管地址會有所不同。

def nft_escrow ( app_id: int, asa_id: int ) ：

返回序列（[

Assert ( Global. group_size () == Int ( 3 )) , # 三個事務的原子傳輸

Assert ( Gtxn [ 0 ] . application_id () == Int ( app_id )) , # 我們正在調用正確的應用程序

斷言（Gtxn [ 1 ] .type_enum （）== TxnType.Payment ），

斷言( Gtxn [ 2 ] .asset_amount ( ) == Int ( 1 )) ,

Assert ( Gtxn [ 2 ] . xfer_asset () == Int ( asa_id )) , # 我們正在轉移正確的 NFT

斷言( Gtxn [ 2 ] .fee ( ) < = Int ( 1000 )) ,

斷言( Gtxn [ 2 ] .asset_close_to () == Global.zero_address ( )) ,

斷言( Gtxn [ 2 ] .rekey_to () == Global.zero_address ( )) ,

返回( Int ( 1 ))

])

我們使用托管無狀態智能合約完成了 NFTMarketplace 應用程序中的所有 PyTeal 代碼。Algorand 區塊鏈將用于運行此代碼。我們現在唯一要做的就是將與合約的溝通付諸行動。

第四步：通訊服務

交易是我們與智能合約溝通的方式。將交易的創建分成不同的功能是一種聰明的方法。此外，我們將邏輯功能劃分為不同的類，我們將其稱為服務。

我們的應用程序中有兩種類型的服務：

• 與有狀態智能合約的所有交互都是通過“NFTMarketplace”服務實現的。我們可以使用該服務來調用“NFTMarketplaceInterface”中實現的方法。此外，我們還有另一種將應用程序部署到區塊鏈的方式。

• “NFTMarketplace”中提供以下方法：

  我們不在應用程序的 UI 中使用“stop_sell_offer”方法；因此，我們沒有將它包含在服務類中。實現必要的事務以執行該方法是一項可取的練習。

• “應用程序初始化”

• “初始化托管”

• “fund_escrow”

• “make_sell_offer”

• “買_nft”

• “NFTService”允許我們構建 NFT、修改其憑據并向其中添加用戶。
  因此，“NFTService”由以下方法組成：

• “創建_nft”

• “change_nft_credentials”

• “選擇參加”

NFT 市場

每個“NFTMarketplace”服務實例都將代表一個單獨的有狀態智能合約，該合約已被放置在網絡上。這些合約中的每一個都負責監督單個 NFT 的狀態。

以下代碼用于設置智能合約：

NFTMarketplace類：

def __init__ ( self, admin_pk, admin_address, nft_id, client ) :

       自己。admin_pk = admin_pk

       自己。admin_address = admin_address

       自己。nft_id = nft_id

       自己?？蛻?客戶

       自己。青色版本= 4

       自己。nft_marketplace_asc1 = NFTMarketplaceASC1 ()

       自己。app_id = 無

除了適當的參數外，我們還在類的構造方法中初始化“NFTMarketplaceASC1”有狀態智能合約。提交給網絡的TEAL碼將從該物品中獲取。

我們定義的第一個函數生成并執行提交有狀態智能合約的網絡交易。

我們可以通過以下代碼獲得它：

def app_initialization （自我，nft_owner_address ）：

       批準程序編譯 = compileTeal (

           自己。nft_marketplace_asc1 。批準程序（），

           模式=模式。應用，

           版本= 4 ,

)

       clear_program_compiled = compileTeal (

           自己。nft_marketplace_asc1 。clear_program () ,

           模式=模式。應用，

           版本= 4

)

       批準程序字節 = 網絡交互。編譯程序（

           客戶=自己?？蛻舳?，source_code=approval_program_compiled

)

       clear_program_bytes = 網絡交互。編譯程序（

           客戶=自己?？蛻舳?，source_code=clear_program_compiled

)

       app_args = [

decode_address ( nft_owner_address ) ,

decode_address ( self.admin_address ) , _

]

       app_transaction = ApplicationTransactionRepository。創建應用程序（

           客戶=自己?？蛻?，

           creator_private_key=自己。admin_pk ,

           批準程序=批準程序字節，

           clear_program=clear_program_bytes,

           全局模式=自我。nft_marketplace_asc1 。全局模式，

           local_schema=self。nft_marketplace_asc1 。local_schema ,

           app_args=app_args,

           外國資產= [自我。nft_id ] ,

)

       tx_id = 網絡交互。提交交易（

           自己?？蛻舳?，事務=app_transaction

)

       交易響應=自我?？蛻舳?。pending_transaction_info ( tx_id )

       自己。app_id = transaction_response [ “應用程序索引” ]

返回tx_id

上述函數的目標是定義一個應用程序創建事務并將其提交到網絡。該事務可以接受各種參數，因此我們需要指定我們將在應用程序中使用的參數?！癗FTMarketplaceASC1”合約的“app_initialization”方法定義了對具體參數的需求。

以下階段總結了實現邏輯：

• 從有狀態的智能合約中，我們獲取并編譯明確和批準程序。

• 生成一個存儲“nft_owner_address”和“admin_address”的“app_args”數組。當應用程序創建事務時，這個數組將被發送到“apps_args”。

• 在應用程序中傳輸“nft_id”以創建交易的 foreign_assets 字段參數。

如果此交易成功完成，我們已成功部署應用程序來管理具有特定“nft_id”的 NFT 的銷售和轉售。

“ nft_id”和“app_id”是初始化托管地址的必要參數，現在可用。我們稍后會使用這個地址作為 NFT 中的回撥地址。

我們可以使用“nft_escrow”函數獲取托管地址和托管字節：

   @財產

默認托管字節（自我）：

如果自我。app_id為無：

           raise ValueError ( "App 未部署" )

       escrow_fund_program_compiled = compileTeal (

nft_escrow ( app_id= self.app_id , asa_id= self.nft_id ) ,

           模式=模式。簽名，

           版本= 4 ,

)

返回網絡交互。編譯程序（

           客戶=自己?？蛻舳?，source_code=escrow_fund_program_compiled

)

   @財產

def escrow_address ( self ) ：

返回算法邏輯。地址（self.escrow_bytes ）_

我們現在需要執行“initialize_escrow”函數來實現相應的交易，進而在有狀態的智能合約中設置托管地址。請記住，在與此功能交互之前，我們必須修改 NFT 的管理憑據。在“NFTService”中，將對修改NFT管理的代碼進行說明。

定義初始化托管（自我）：

       app_args = [

           自己。nft_marketplace_asc1 。應用方法。初始化托管，

decode_address ( self. escrow_address ) ,

]

       initialize_escrow_txn = ApplicationTransactionRepository。調用應用程序（

           客戶=自己?？蛻?，

           caller_private_key=self。admin_pk ,

           app_id=自己。app_id ,

           on_complete=algo_txn。完成。NoOpOC ,

           app_args=app_args,

           外國資產= [自我。nft_id ] ,

)

       tx_id = 網絡交互。提交交易（

           自己?？蛻舳?，事務=initialize_escrow_txn

)

返回tx_id

成功提交“initialize_escrow”交易后，有狀態智能合約的起始狀態更新為“AppState.active” 。我們必須執行“make_sell_offer”和“buy_nft”方法。

“ make_sell_offer”只是一個普通的應用程序調用事務，我們傳遞兩個參數：方法名稱和賣出報價。當交易發送者擁有必要的 NFT 時，有狀態的智能合約將確認交易。

def make_sell_offer ( self, sell_price: int, nft_owner_pk ) ：

       app_args = [自我。nft_marketplace_asc1 。應用方法。make_sell_offer , sell_price ]

       app_call_txn = ApplicationTransactionRepository。調用應用程序（

           客戶=自己?？蛻?，

           caller_private_key=nft_owner_pk,

           app_id=自己。app_id ,

           on_complete=algo_txn。完成。NoOpOC ,

           app_args=app_args,

           sign_transaction=真，

)

       tx_id = 網絡交互。submit_transaction ( self.client , transaction= app_call_txn )

返回tx_id

按照慣例，我們必須執行最復雜的方法。要購買 NFT，我們必須提交三個原子轉移交易：

1. 買方對應用程序調用進行的應用程序調用交易。我們只將方法名作為應用參數發送，比較簡單。

2. 買方向 NFT 的賣方進行支付交易。此交易的價值應與銷售要約中指定的金額相同。

3. 從托管地址到購買者地址的原子轉移交易。托管地址也是 NFT 的回撥地址，NFT 可以從一個地址轉移到另一個地址。此交易必須使用邏輯簽名進行簽名。一旦托管合約中的 TEAL 邏輯被評估為 true，則交易被批準。

生成購買 NFT 所需的所有交易的“buy_nft”函數在下面的代碼中進行了描述。

def buy_nft （自我，nft_owner_address，buyer_address，buyer_pk，buy_price ）：

# 1. 應用調用txn

       app_args = [

           自己。nft_marketplace_asc1 。應用方法。買

]

       app_call_txn = ApplicationTransactionRepository。call_application ( client = self.client ,

                                                                        caller_private_key=buyer_pk,

                                                                        app_id=自己。app_id ,

                                                                        on_complete=algo_txn。完成。NoOpOC ,

                                                                        app_args=app_args,

                                                                        sign_transaction=假）

# 2. 支付交易：買家->賣家

       asa_buy_payment_txn = PaymentTransactionRepository。付款（客戶=自我?？蛻?，

                                                                  發件人地址=買家地址，

                                                                  接收者地址=nft_owner_address，

                                                                  金額=購買價格，

                                                                  sender_private_key=無，

                                                                  sign_transaction=假）

# 3. 資產轉移交易：托管 -> 買方

       asa_transfer_txn = ASATransactionRepository。asa_transfer （客戶=自我?？蛻?，

                                                                發件人地址=自己。托管地址，

                                                                接收者地址=買家地址，

                                                                數量= 1 ,

                                                                asa_id=自己。nft_id ,

                                                                撤銷目標=nft_owner_address，

                                                                sender_private_key=無，

                                                                sign_transaction=假）

# 原子傳輸

       gid = algo_txn。calculate_group_id ([ app_call_txn,

                                          asa_buy_payment_txn,

                                          asa_transfer_txn ])

       app_call_txn。組= gid

       asa_buy_payment_txn。組= gid

       asa_transfer_txn。組= gid

       app_call_txn_signed = app_call_txn。簽名( buyer_pk )

       asa_buy_txn_signed = asa_buy_payment_txn。簽名( buyer_pk )

       asa_transfer_txn_logic_signature = algo_txn。LogicSig ( self.escrow_bytes ) _

       asa_transfer_txn_signed = algo_txn。LogicSigTransaction ( asa_transfer_txn, asa_transfer_txn_logic_signature )

       簽名組 = [ app_call_txn_signed,

                       asa_buy_txn_signed,

                       asa_transfer_txn_signed ]

       tx_id = 自我?？蛻舳?。發送交易（簽名組）

返回tx_id

執行此方法后，“NFTMarketplace”服務現已完成。

NFT服務

“NFTService”類的每個實例將負責區塊鏈上的單個 NFT。生成 NFT 的必要參數，例如創建者的地址、NFT 名稱和包含 ipfs 圖像的可選 URL，需要發送到初始化程序。

NFTService類：

def __init__ (

           自己，

           nft_creator_address: str,

           nft_creator_pk：str，

           客戶，

           單位名稱：str，

           資產名稱：str，

           nft_url=無，

) :

       自己。nft_creator_address = nft_creator_address

       自己。nft_creator_pk = nft_creator_pk

       自己?？蛻?客戶

       自己。單位名稱= 單位名稱

       自己。資產名稱= 資產名稱

       自己。nft_url = nft_url

       自己。nft_id = 無

資產配置交易用于生成 NFT。NFT 的每個管理字段此時都已填充，我們稍后可以更改。如果我們用這些管理憑證離開 NFT，有狀態的智能合約應該將其關閉。

def create_nft （自我）：

       signed_txn = ASATransactionRepository。create_non_fungible_asa (

           客戶=自己?？蛻?，

           creator_private_key=自己。nft_creator_pk ,

           單位名稱=自我。單位名稱，

           資產名稱=自己。資產名稱，

           注意=無，

           經理地址=自己。nft_creator_address ,

           保留地址=自己。nft_creator_address ,

           凍結地址=自己。nft_creator_address ,

           回撥地址=自己。nft_creator_address ,

           網址=自我。nft_url ,

           default_frozen=真，

           sign_transaction=真，

)

       nft_id, tx_id = 網絡交互。submit_asa_creation (

           客戶=自己?？蛻舳?，事務=已簽名_txn

)

       自己。nft_id = nft_id

返回tx_id

實現了“change_nft_credentials_txn”方法，該方法清除了除托管地址之外的所有 NFT 憑證。

def change_nft_credentials_txn ( self, escrow_address ) ：

       txn = ASATransactionRepository。change_asa_management (

           客戶=自己?？蛻?，

           current_manager_pk=自己。nft_creator_pk ,

           asa_id=自己。nft_id ,

           經理地址= “” ，

           保留地址= “” ，

           凍結地址= “” ，

           strict_empty_address_check=假，

           clawback_address=escrow_address,

           sign_transaction=真，

)

       tx_id = 網絡交互。submit_transaction ( self.client , transaction= txn )

返回tx_id

最后，我們必須執行一種簡單的方法，允許用戶選擇特定的 NFT。這是 Algorand 網絡的一項重要特性，它可以防止用戶接收未經授權存儲在其錢包中的代幣。成功選擇后，用戶可以獲得 Algorand 標準資產。

def opt_in ( self, account_pk ) :

       opt_in_txn = ASATransactionRepository。asa_opt_in (

           客戶=自己?？蛻舳?，sender_private_key=account_pk，asa_id=self。nft_id

)

       tx_id = 網絡交互。submit_transaction ( self.client , transaction= opt_in_txn )

返回tx_id

第 5 步：部署 Algorand 測試網

最后，我們已經執行了一切。多虧了這些服務，我們現在可以在 Algorand 測試網上輕松部署和測試 NFTMarketplace 應用程序。下面的腳本復制了銷售報價并由特定買家執行。從下面的代碼中，我們可以看到一切都抽象得很好，使得事務執行變得方便。

nft_service。創建_nft ()

nft_marketplace_service。app_initialization ( nft_owner_address=admin_addr )

nft_service。change_nft_credentials_txn ( escrow_address= nft_marketplace_service.escrow_address )

nft_marketplace_service。初始化托管（）

nft_marketplace_service?；鹜泄埽ǎ?/p>

nft_marketplace_service。make_sell_offer ( sell_price= 100000 , nft_owner_pk=admin_pk )

nft_service。opt_in ( buyer_pk )

nft_marketplace_service。buy_nft ( nft_owner_address=admin_addr,

                               買家地址=買家地址，

                               買家pk=買家pk，

                               購買價格= 100000 )

結論

不可替代代幣日益流行，現有 NFT 市場（如 Axie Infinity、Rarible 和 OpenSea）的流量也在增加。大公司發現這一新的技術浪潮是一個有利可圖的機會，可以投資并利用該機會實現業務增長，充分利用其潛力。隨著巨大的業務增長可能性，對由強大的區塊鏈生態系統驅動的 NFT 市場的需求出現了。

盡管有許多區塊鏈平臺可用，但 Algorand 是 NFT 市場開發最好和最可靠的平臺之一。它的推出是為了解決同時實現可擴展性、安全性和去中心化的區塊鏈三難困境。作為最快的網絡之一，它可以在不到五秒的時間內完成交易，也是一種具有成本效益的協議。其獨特的 Pure Proof-of-Stake 共識機制、強大的安全性、有保證的最終性、全球范圍的覆蓋范圍、廣泛的去中心化和低交易成本使其成為開發和部署標準 NFT 市場的最佳平臺之一。