Blinks sind metadatenreiche Links, die On-Chain-Aktivitäten im gesamten Solana-Ökosystem darstellen und ermöglichen, ohne dass zu einer anderen App oder Webseite navigiert werden muss.
Blinks unterstützt eine breite Palette von Aktivitäten, die durch Solana Actions ermöglicht werden
und ermöglichen Benutzern in erster Linie die Interaktion mit der Blockchain über soziale Medien und andere Off-Chain-Plattformen.
Zu den Anwendungsfällen gehören:
- NFT-Handel und Prägung,
- Spenden,
- Crowdfunding,
- Token-Swaps,
- Lotterie-/Casino-Apps und vieles mehr
In diesem Artikel werden wir eine einfache Blink-App erkunden, die sich auf das Prägen von NFTs mit Go konzentriert. Während sich der Artikel auf Go konzentriert, gelten die Kernkonzepte für jede Blink-App. Den vollständigen Code finden Sie auf GitHub.
Wir beginnen mit der Einrichtung eines grundlegenden Webservers mithilfe des Gin-Frameworks sowie der erforderlichen CORS-Konfiguration gemäß der Spezifikation. Außerdem definieren wir einige Endpunkte, die weiter unten ausführlich besprochen werden.
func main() {
var (
corsConfig = cors.DefaultConfig()
router = gin.Default()
port = os.Getenv("PORT")
)
corsConfig.AllowAllOrigins = true
corsConfig.AddAllowHeaders([]string{"Content-Length", "Content-Type", "Access-Control-Allow-Origin"}...)
corsConfig.AddAllowMethods([]string{"GET", "POST", "OPTIONS"}...)
router.Use(cors.New(corsConfig))
router.GET("/actions.json", app.ActionsRulesHandler)
router.GET("/api/actions/mint_nft", app.GetActionsHandler)
router.OPTIONS("/api/actions/mint_nft", app.OptionsHandler)
router.POST("/api/actions/mint_nft", app.PostHandler)
log.Println("StickyLabs Blink Active ?")
if port == "" {
port = "8081"
}
log.Println("Server is running")
err := router.Run(fmt.Sprintf(":%v", port))
if err != nil {
log.Fatal(err)
return
}
}
Nach dem Login kopieren
Der Kern jeder Blinks-Anwendung liegt in der Replikation der Solana Actions API Spec. Unten finden Sie eine visuelle Darstellung der Funktionsweise von Blinks.
Aktionshandler
Blinks auf Solana verwendet ein Aktions-URL-Schema, um einen metadatenreichen Link bereitzustellen, der verschiedene Aktivitäten in der Kette ermöglicht. In diesem Abschnitt werden die primären Handler beschrieben, die für die Verarbeitung der Mint-NFT-Aktion auf /api/actions/mint_nft
verantwortlich sind
-
GET-Handler: Gibt Metadaten, unterstützte Aktionen und erforderliche Parameter zurück.
type ActionGetResponse struct {
Title string `json:"title"`
Icon string `json:"icon"`
Description string `json:"description"`
Label string `json:"label"`
Links struct {
Actions []Actions `json:"actions"`
} `json:"links"`
}
type Actions struct {
Label string `json:"label"`
Href string `json:"href"`
Parameters []ActionParameters `json:"parameters,omitempty"`
}
type ActionParameters struct {
Name string `json:"name"`
Label string `json:"label"`
Required bool `json:"required"`
}
func GetActionsHandler(c *gin.Context) {
payload := ActionGetResponse{
Title: "Actions Example - Mint NFT",
Icon: c.Request.URL.Scheme + "://" + c.Request.URL.Host + "/solana_devs.jpg",
Description: "Transfer SOL to another Solana wallet",
Label: "Transfer",
}
payload.Links.Actions = []Actions{
{"Mint NFT", "/api/actions/mint_nft", []ActionParameters{
{"name", "Enter the Name of the NFT", true},
{"symbol", "Enter the Symbol of the NFT", true},
{"uri", "Enter the Uri of the NFT", true},
}},
}
c.JSON(http.StatusOK, payload)
}
Nach dem Login kopieren
-
OPTIONS: Der OPTIONS-Handler verarbeitet CORS-Anforderungen und stellt die Kompatibilität mit Browsern und anderen Client-Anfragemechanismen sicher.
var ACTIONS_CORS_HEADERS = map[string]string{
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET,POST,OPTIONS",
"Access-Control-Allow-Headers": "Content-Type",
}
func OptionsHandler(c *gin.Context) {
for key, value := range ACTIONS_CORS_HEADERS {
c.Header(key, value)
}
c.Status(http.StatusOK)
}
Nach dem Login kopieren
-
POST-Handler: Der POST-Handler akzeptiert Abfrageparameter, analysiert das als JSON bereitgestellte Konto in Base58 und gibt eine Base64-codierte serialisierte Transaktion zusammen mit einer Nachricht zurück, die der Benutzer signieren und ausführen muss.
type MintNFTParams struct {
Name string `form:"name" binding:"required"`
Symbol string `form:"symbol" binding:"required"`
URI string `form:"uri" binding:"required"`
}
// { "account": "<account>" } //JSON
type ActionPostRequest struct {
Account string `json:"account"`
}
type ActionPostResponse struct {
Fields ActionPostResponseFields `json:"fields"`
}
type ActionPostResponseFields struct {
Transaction string `json:"transaction"`
Message string `json:"message"`
}
func PostHandler(c *gin.Context) {
var (
qPayload MintNFTParams
request ActionPostRequest
response ActionPostResponse
)
if err := c.ShouldBindQuery(&qPayload); err != nil {
c.JSON(http.StatusBadRequest, ActionError{Message: "Invalid Query Params"})
return
}
if err := c.ShouldBindJSON(&request); err != nil {
log.Println(err)
c.JSON(http.StatusBadRequest, ActionError{Message: "Invalid request"})
return
}
account, err := types.AccountFromBase58(request.Account)
if err != nil {
log.Println(err)
c.JSON(http.StatusBadRequest, ActionError{Message: "Invalid request; Error validating account"})
return
}
response.Fields.Transaction, response.Fields.Message = mintNFT(qPayload, account)
c.JSON(http.StatusOK, response)
}
Nach dem Login kopieren
Die mintNFT-Funktion nutzt Solana-Go-SDK zum Prägen von NFTs, mit wenigen Anpassungen.
func mintNFT(metadata MintNFTParams, feePayer types.Account) (transaction, message string) {
message = fmt.Sprintf("Mint NFT %s", metadata.Name)
c := client.NewClient(rpc.DevnetRPCEndpoint)
log.Println(metadata)
mint := types.NewAccount()
fmt.Printf("NFT: %v\n", mint.PublicKey.ToBase58())
collection := types.NewAccount()
fmt.Printf("collection: %v\n", collection.PublicKey.ToBase58())
ata, _, err := common.FindAssociatedTokenAddress(feePayer.PublicKey, mint.PublicKey)
if err != nil {
log.Fatalf("failed to find a valid ata, err: %v", err)
}
tokenMetadataPubkey, err := token_metadata.GetTokenMetaPubkey(mint.PublicKey)
if err != nil {
log.Fatalf("failed to find a valid token metadata, err: %v", err)
}
tokenMasterEditionPubkey, err := token_metadata.GetMasterEdition(mint.PublicKey)
if err != nil {
log.Fatalf("failed to find a valid master edition, err: %v", err)
}
mintAccountRent, err := c.GetMinimumBalanceForRentExemption(context.Background(), token.MintAccountSize)
if err != nil {
log.Fatalf("failed to get mint account rent, err: %v", err)
}
recentBlockhashResponse, err := c.GetLatestBlockhash(context.Background())
if err != nil {
log.Fatalf("failed to get recent blockhash, err: %v", err)
}
tx, err := types.NewTransaction(types.NewTransactionParam{
Signers: []types.Account{mint, feePayer},
Message: types.NewMessage(types.NewMessageParam{
FeePayer: feePayer.PublicKey,
RecentBlockhash: recentBlockhashResponse.Blockhash,
Instructions: []types.Instruction{
system.CreateAccount(system.CreateAccountParam{
From: feePayer.PublicKey,
New: mint.PublicKey,
Owner: common.TokenProgramID,
Lamports: mintAccountRent,
Space: token.MintAccountSize,
}),
token.InitializeMint(token.InitializeMintParam{
Decimals: 0,
Mint: mint.PublicKey,
MintAuth: feePayer.PublicKey,
FreezeAuth: &feePayer.PublicKey,
}),
token_metadata.CreateMetadataAccountV3(token_metadata.CreateMetadataAccountV3Param{
Metadata: tokenMetadataPubkey,
Mint: mint.PublicKey,
MintAuthority: feePayer.PublicKey,
Payer: feePayer.PublicKey,
UpdateAuthority: feePayer.PublicKey,
UpdateAuthorityIsSigner: true,
IsMutable: true,
Data: token_metadata.DataV2{
Name: metadata.Name,
Symbol: metadata.Symbol,
Uri: metadata.URI,
SellerFeeBasisPoints: 100,
Creators: &[]token_metadata.Creator{
// tODO rede && Minter
{
Address: feePayer.PublicKey,
Verified: true,
Share: 100,
},
},
Collection: &token_metadata.Collection{
Verified: false,
Key: collection.PublicKey,
},
Uses: nil,
},
CollectionDetails: nil,
}),
associated_token_account.Create(associated_token_account.CreateParam{
Funder: feePayer.PublicKey,
Owner: feePayer.PublicKey,
Mint: mint.PublicKey,
AssociatedTokenAccount: ata,
}),
token.MintTo(token.MintToParam{
Mint: mint.PublicKey,
To: ata,
Auth: feePayer.PublicKey,
Amount: 1,
}),
token_metadata.CreateMasterEditionV3(token_metadata.CreateMasterEditionParam{
Edition: tokenMasterEditionPubkey,
Mint: mint.PublicKey,
UpdateAuthority: feePayer.PublicKey,
MintAuthority: feePayer.PublicKey,
Metadata: tokenMetadataPubkey,
Payer: feePayer.PublicKey,
MaxSupply: pointer.Get[uint64](0),
}),
},
}),
})
if err != nil {
log.Fatalf("failed to new a tx, err: %v", err)
}
serialized, err := tx.Serialize()
if err != nil {
log.Fatal(err)
}
transaction = base64.StdEncoding.EncodeToString(serialized)
return
}
Nach dem Login kopieren
-
Fehlerbehandlung: Aktionen sollten benutzerfreundliche Fehler im folgenden Format zurückgeben.
// { "message" : "Insert Error Message" } //JSON
type ActionError struct {
Message string `json:"message"`
}
Nach dem Login kopieren
-
actions.json: Die Datei actions.json sollte im Stammverzeichnis der Domäne gespeichert werden. Es bietet Kunden Anweisungen dazu, welche URLs Solana-Aktionen unterstützen, und stellt Zuordnungen bereit, die zum Durchführen von GET-Anfragen an die Blink-App verwendet werden können. Der Einfachheit halber würden wir eine JSON-Antwort vom URL-Pfad zurückgeben
func ActionsRulesHandler(c *gin.Context) {
payload := gin.H{
"rules": []gin.H{
{
"pathPattern": "/*",
"apiPath": "/api/actions/*",
},
{
"pathPattern": "/api/actions/**",
"apiPath": "/api/actions/**",
},
},
}
c.JSON(http.StatusOK, payload)
}
Nach dem Login kopieren
Testen Sie Ihren Blink
Nach der Bereitstellung Ihrer App können Sie die Blinks Inspector-App zum Testen verwenden.
Abschluss
Ich hoffe, dieser Artikel bietet eine praktische Einführung in die Erstellung von Blinks-Anwendungen auf Solana mit Go. Den gesamten Code finden Sie hier.
Weitere Informationen zum Solana Actions-Framework und eine detaillierte Dokumentation finden Sie in den offiziellen Ressourcen von Solana
Das obige ist der detaillierte Inhalt vonSolana blinkt mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
