Web3.swift

⛓️ Web3

Web3.Swift ist eine Swift -Bibliothek zur Unterzeichnung von Transaktionen und zur Interaktion mit intelligenten Verträgen im Ethereum -Netzwerk.

Sie können eine Verbindung zu einem Geth- oder Erigon -Ethereum -Knoten (wie Kettennoten) herstellen, um Transaktionen zu senden und Werte aus intelligenten Verträgen zu lesen, ohne Ihre eigenen Implementierungen der Protokolle zu schreiben.

Web3.Swift unterstützt iOS, macOS, TVOS, WatchOS und Linux mit Swift Package Manager.

Beispiel

Überprüfen Sie die Verwendung unten oder schauen Sie sich die Repositories -Tests an.

Warum?

Es gibt bereits eine Web3 -Bibliothek in Swift. Wir kennen ihre Stärken und Schwächen und für unseren Anwendungsfall haben sie einfach nicht gearbeitet.

Web3.swift wurde unter Berücksichtigung von Modularität, Portabilität, Geschwindigkeit und Effizienz erstellt.

Ok, danke für die Schlagworte. Aber was bedeutet das eigentlich?

? Modularität

Web3.swift wurde als modular erstellt. Wenn Sie das grundlegende Web3 -SPM -Produkt installieren/verwenden, erhalten Sie Zugriff auf die grundlegendsten Funktionen wie Transaktionsunterzeichnung und Interaktion mit einem HTTP -RPC -Server.
Wenn Sie Unterstützung für IPC RPC oder etwas anderes hinzufügen möchten, können Sie einfach eine Bibliothek erstellen, die von Web3 abhängt und diese genaue Funktionalität implementiert. Mehr dazu später.
Wenn Sie PromiseKit -Erweiterungen für die Web3 -Anrufe verwenden möchten, können Sie entweder das bereitgestellte Verheißungs -SPM -Produkt verwenden oder Ihr eigenes erstellen.
Wenn Sie Json Abis bequem für Ethereum -Smart Contracts analysieren möchten, können Sie das bereitgestellte ABI -Parsing -SPM -Produkt verwenden.

Wenn Sie Web3.swift , die noch nicht bereitgestellt werden, Funktionen hinzufügen möchten, müssen Sie nicht warten, bis sie in einer Versionsbeule verschmolzen und veröffentlicht werden. Sie können die Funktionalität in Ihrer eigenen App einfach erweitern/aktualisieren, da unsere APIs für Änderungen sehr offen sind.
Wenn Sie beispielsweise eine Web3 -Methode hinzufügen möchten, die noch nicht von Web3.swift bereitgestellt wird (wir werden nur infura unterstützte Methoden unterstützen), müssen Sie nur 3 Codezeilen hinzufügen (abhängig von den Eingabe- und Ausgabeparametern der Methode). Das Hinzufügen von IPC -RPC -Support würde nur ein Protokoll implementieren und Anfragen beantworten.

Wie Sie sehen können, ist mit Web3.swift alles möglich.

Portabilität

Einer der Hauptgründe, warum wir an diesem Projekt gearbeitet haben, ist, dass wir es mit Swift Paket Manager auf verschiedenen Plattformen verwenden wollten.
Aus diesem Grund ist Web3.swift über Swift Paket Manager unter iOS, macOS, tvos, watchos und Linux erhältlich.

Hinweis: Für SPM testen wir nur iOS, macOS und offiziell unterstützte Linux -Verteilungen (derzeit Ubuntu 16.04 und 20.04), sollte jedoch mit allen kleinen Endian -Systemen kompatibel sein, die den Swift Compiler, Foundation und GLIBC zusammenstellen können.

⚡ Geschwindigkeit und Effizienz

Wir versuchen, diese Bibliothek so schnell wie möglich zu gestalten, während wir versuchen, eine API bereitzustellen, die Ihren Entwicklungsworkflow so erhöht, dass Sie sich darauf konzentrieren können, großartige DApps zu erstellen, anstatt sich um Implementierungsdetails zu kümmern.

Alle unsere APIs sind fadensicher und für sehr gleichzeitige Anwendungen verwendet.

Installation

Swift Package Manager

Web3 ist mit Swift Paket Manager V5 (Swift 5 und höher) kompatibel. Fügen Sie es einfach zu den Abhängigkeiten in Ihrem Package.swift hinzu.

dependencies: [
    . package ( url : " https://github.com/Boilertalk/Web3.swift.git " , from : " 0.6.0 " )
]

Und fügen Sie es dann zu Ihren Zielabhängigkeiten hinzu:

targets: [
    . target (
        name : " MyProject " ,
        dependencies : [
            . product ( name : " Web3 " , package : " Web3.swift " ) ,
            . product ( name : " Web3PromiseKit " , package : " Web3.swift " ) ,
            . product ( name : " Web3ContractABI " , package : " Web3.swift " ) ,
        ]
    ) ,
    . testTarget (
        name : " MyProjectTests " ,
        dependencies : [ " MyProject " ] )
]

Hinweis: Web3PromiseKit und Web3ContractABI sind optional, und Sie müssen sie nur in Ihre Zielabhängigkeiten einfügen (und später importieren), wenn Sie sie verwenden möchten.

Nach der Installation können Sie Web3 in Ihre .swift -Dateien importieren.

import Web3

// Optional
import Web3PromiseKit
import Web3ContractABI

Cocoapods und Karthago

Aufgrund einer internen Entscheidung haben wir die Unterstützung anderer Paketmanager als SPM ab Version 0.5.0 eingestellt.

Ein wenig über diese Entscheidung einzugehen: Mit Xcode 11 und Swift 5.1 haben wir einen Punkt mit Swift Paket Manager erreicht, an dem es langsam begann, andere Paketmanager irrelevant zu machen. Sie können bereits alle Ihre Abhängigkeiten im Xcode -Projekt mit Swift Paket Manager laden.
Mit weiteren Updates wurde es noch häufiger. Cocoapods und Karthago -Betreuer verloren das Interesse an ihrem Projekt und stellten die Aufrechterhaltung ein. Es gibt viele ungelöste Probleme, viele Probleme, insbesondere für Bibliotheksentwickler mit Cocoapods.

So viel Ärger ohne wirklichen Gewinn. Benutzer können bereits Abhängigkeiten einfügen, die SPM in ihr Xcode -Projekt unterstützen. Warum also die Mühe machen?

Die Antwort ist einfach. Einige verwenden noch Xcode <11 und einige Bibliotheksentwickler sind in ihren eigenen Schoten/Karthöden auf Web3 angewiesen.

Die Entscheidung war hart und dauerte einige Zeit. Nachdem wir gesehen hatten, dass die letzte Version bereits sehr stabil war und in vielen Produktions -Apps verwendet wurde, haben wir uns jetzt entschlossen, jetzt mit diesem Schritt zu beginnen.
Xcode 10 ist bereits mehr als 2 Jahre alt. Die meisten Projekte wurden bereits aktualisiert, diejenigen, die kein viel größeres Problem hatten als Web3.swift, die keine Updates für Cocoapods erstellen ...
Bibliotheksbesitzer je nach Web3.Swift werden aufgefordert, auch Cocoapods und Karthago -Unterstützung fallen zu lassen.

SPM ist die Zukunft. Für alle Cocoapods und Karthago -Benutzer, die es verwenden, weil viele Bibliotheken noch nicht zu SPM gewechselt sind: Sie können immer noch Web3 als SPM -Produkt in Ihren .xcworkspace oder .xcodeproj hinzufügen und alle anderen Abhängigkeiten in Cocoapods/Karthage behalten. Aber immer noch. Wir ermutigen Sie, mit so vielen Abhängigkeiten wie möglich zu SPM zu wechseln. Besser früher als später. Siehe den nächsten Abschnitt, wie das geht.

Xcode

Mit Xcode 11 oder später (für iOS, macOS oder andere Apple -Plattformen) können Sie SPM -Pakete sehr einfach hinzufügen.

Wählen Sie in XCode Ihr Projekt aus der Dropdown -Down -Down -Art aus, das Projekt, kein einzelnes Ziel, in den Registerkarten Swift Packages auswählen.
Anschließend können Sie auf das Symbol + klicken und die URL in dieses Repository (https://github.com/boilertalk/web3.Swift) einfügen.
Jetzt können Sie alle Produkte auswählen und einfach auf Weiter klicken, bis die Abhängigkeit hinzugefügt wurde.

Das war's. Wenn Sie Ihre Änderungen vorantreiben, macht auch Ihr CI keine Probleme. Keine Probleme mit veralteten Spezifikationsrepositories, keine Probleme mit einigen seltsamen Linkerfehlern, die nur manchmal/mit einigen Abhängigkeiten auftreten.

Wenn Sie weitere Anleitung benötigen, treten Sie unserer Telegrammgruppe bei und wir helfen Ihnen. https://t.me/web3_swift

Verwendung

Interaktion mit einem Ethereum -Knoten

Mit Web3.swift können Sie einen Ethereum -Knoten auf einem Server verwenden, um mit Ethereum zu kommunizieren.
Sie können unterschriebene Transaktionen senden, Vertragsdaten lesen, Vertragsfunktionen aufrufen und vieles mehr.

Die Basisklasse für alle verfügbaren Methoden ist Web3 . Sie können es beispielsweise mit einem HTTP -Anbieter instanziieren:

 let web3 = Web3 ( rpcURL : " https://mainnet.infura.io/<your_infura_id> " )

Alle web3_ -Methoden sind direkt über die Web3 -Struktur verfügbar. Die net_ -Methoden sind in der net -Struktur in der web3 -Struktur verfügbar. Die eth_ -Methoden sind im Rahmen der eth -Struktur in der web3 -Struktur verfügbar.

Bitte beachten Sie die folgenden Beispiele

Hinweis: Für die Beispiele müssen Sie zuerst Web3 importieren und versprechen

Anfrage web3_clientversion

Gibt die aktuelle Client -Version zurück.

Parameter

keiner

Zurück

String - Die aktuelle Clientversion

 firstly {
    web3 . clientVersion ( )
} . done { version in
    print ( version )
} . catch { error in
    print ( " Error " )
} 

Anfordern net_version

Gibt die aktuelle Netzwerk -ID zurück.

Parameter

keiner

Zurück

String - Die aktuelle Netzwerk -ID

 firstly {
    web3 . net . version ( )
} . done { version in
    print ( version )
} . catch { error in
    print ( " Error " )
} 

Anfordern net_peercount

Gibt die Anzahl der mit dem Client verbundenen Kollegen zurück.

Parameter

keiner

Zurück

EthereumQuantity - Bigint der Anzahl der vernetzten Kollegen.

 firstly {
    web3 . net . peerCount ( )
} . done { ethereumQuantity in
    print ( ethereumQuantity . quantity )
} . catch { error in
    print ( " Error " )
} 

RAW -Transaktion senden

Erstellt neue Nachrichtenanruftransaktion oder eine Vertragserstellung für signierte Transaktionen.

Parameter

1. EthereumTransaction : die signierte Transaktion

Zurück

EthereumData , 32 Bytes - der Transaktions -Hash oder der Null -Hash, wenn die Transaktion noch nicht verfügbar ist

Um eine ETH zu senden, müssen Sie zunächst die aktuelle Transaktionszahl des Absenders (Nonce) erhalten, die Transaktion erstellen, unterschreiben und dann senden.

 let privateKey = try ! EthereumPrivateKey ( hexPrivateKey : " 0xa26da69ed1df3ba4bb2a231d506b711eace012f1bd2571dfbfff9650b03375af " )
firstly {
    web3 . eth . getTransactionCount ( address : privateKey . address , block : . latest )
} . then { nonce in
    let tx = try EthereumTransaction (
        nonce : nonce ,
        gasPrice : EthereumQuantity ( quantity : 21 . gwei ) ,
        gas : 21000 ,
        to : EthereumAddress ( hex : " 0xC0866A1a0ed41e1aa75c932cA3c55fad847fd90D " , eip55 : true ) ,
        value : EthereumQuantity ( quantity : 1 . eth )
    )
    return try tx . sign ( with : privateKey , chainId : 1 ) . promise
} . then { tx in
    web3 . eth . sendRawTransaction ( transaction : tx )
} . done { hash in
    print ( hash )
} . catch { error in
    print ( error )
} 

Blocktransaktionszahl nach Blocknummer anfordern

 firstly {
    web3 . eth . getBlockTransactionCountByNumber ( block : . block ( 5397389 ) )
} . done { count in
    print ( count ) // 88
} . catch { error in
    print ( error )
} 

Weitere Beispiele

Weitere Beispiele lesen entweder unsere Testfälle, die Web3 -Struktur oder die offizielle Dokumentation von Ethereum JSON RPC.

Vertrags -ABI -Interaktion

Wir bieten ein optionales Modul für die Interaktion mit intelligenten Verträgen an. Um es zu verwenden, müssen Sie Ihre Zielabhängigkeiten in Ihrer Podfile (für SPM) Web3ContractABI hinzufügen. Schauen Sie sich zuerst die Installationsanweisungen an.

Wir bieten zwei verschiedene Optionen, um in Swift Vertrags -ABI -Schnittstellen zu erstellen. Entweder definieren Sie Ihre Funktionen und Ereignisse manuell (oder verwenden eine unserer bereitgestellten Schnittstellen wie ERC20 oder ERC721). Oder Sie analysieren sie von der JSON ABI -Darstellung genau wie in Web3.js.

Statische Verträge

Statische Verträge sind Klassen, StaticContract implementieren. Sie bieten eine Reihe von Funktionen und Ereignissen, die sie aus dem ursprünglichen Smart -Vertrag verwenden möchten. Schauen Sie sich unsere bereitgestellten statischen Verträge als Ausgangspunkt (ERC20 oder ERC721) an.

Unsere statische ERC20 -Schnittstelle heißt GenericERC20Contract , der ERC721 -Vertrag wird GenericERC721Contract bezeichnet. Beide können unterklassifiziert werden, um weitere Funktionen für benutzerdefinierte Verträge hinzuzufügen.

Bei diesen StaticContract Vertragstypen können Sie Ihren Vertrag wie im folgenden Beispiel erstellen und verwenden (wir verwenden in unseren Beispielen erneut Promisekit).

 let web3 = Web3 ( rpcURL : " https://mainnet.infura.io/<your_infura_id> " )

let contractAddress = try EthereumAddress ( hex : " 0x86fa049857e0209aa7d9e616f7eb3b3b78ecfdb0 " , eip55 : true )
let contract = web3 . eth . Contract ( type : GenericERC20Contract . self , address : contractAddress )

// Get balance of some address
firstly {
    try contract . balanceOf ( address : EthereumAddress ( hex : " 0x3edB3b95DDe29580FFC04b46A68a31dD46106a4a " , eip55 : true ) ) . call ( )
} . done { outputs in
    print ( outputs [ " _balance " ] as? BigUInt )
} . catch { error in
    print ( error )
}

// Send some tokens to another address (locally signing the transaction)
let myPrivateKey = try EthereumPrivateKey ( hexPrivateKey : " ... " )
firstly {
    web3 . eth . getTransactionCount ( address : myPrivateKey . address , block : . latest )
} . then { nonce in
    try contract . transfer ( to : EthereumAddress ( hex : " 0x3edB3b95DDe29580FFC04b46A68a31dD46106a4a " , eip55 : true ) , value : 100000 ) . createTransaction (        
        nonce : nonce ,
        gasPrice : EthereumQuantity ( quantity : 21 . gwei ) ,
        maxFeePerGas : nil ,
        maxPriorityFeePerGas : nil ,
        gasLimit : 100000 ,
        from : myPrivateKey . address ,
        value : 0 ,
        accessList : [ : ] ,
        transactionType : . legacy
    ) ! . sign ( with : myPrivateKey ) . promise
} . then { tx in
    web3 . eth . sendRawTransaction ( transaction : tx )
} . done { txHash in
    print ( txHash )
} . catch { error in
    print ( error )
}

// Send some tokens to another address (signing will be done by the node)
let myAddress = try EthereumAddress ( hex : " 0x1f04ef7263804fafb839f0d04e2b5a6a1a57dc60 " , eip55 : true )
firstly {
    web3 . eth . getTransactionCount ( address : myAddress , block : . latest )
} . then { nonce in
    try contract . transfer ( to : EthereumAddress ( hex : " 0x3edB3b95DDe29580FFC04b46A68a31dD46106a4a " , eip55 : true ) , value : 100000 ) . send (        
        nonce : nonce ,
        gasPrice : EthereumQuantity ( quantity : 21 . gwei ) ,
        maxFeePerGas : nil ,
        maxPriorityFeePerGas : nil ,
        gasLimit : 150000 ,
        from : myAddress ,
        value : 0 ,
        accessList : [ : ] ,
        transactionType : . legacy
    )
} . done { txHash in
    print ( txHash )
} . catch { error in
    print ( error )
}

Durch das Erstellen eigener Schnittstellen können Sie mit jedem intelligenten Vertrag interagieren!

Dynamische Verträge

Wenn Sie nur Zugriff auf die JSON ABI eines intelligenten Vertrags haben oder keine statische Vorlage erstellen möchten, können Sie unsere dynamische Vertrags -API verwenden, um die JSON -Zeichenfolge während der Laufzeit in einen nutzbaren Vertrag zu analysieren. Siehe das Beispiel unten.

 let web3 = Web3 ( rpcURL : " https://mainnet.infura.io/<your_infura_id> " )

let contractAddress = try EthereumAddress ( hex : " 0x86fa049857e0209aa7d9e616f7eb3b3b78ecfdb0 " , eip55 : true )
let contractJsonABI = " <your contract ABI as a JSON string> " . data ( using : . utf8 ) !
// You can optionally pass an abiKey param if the actual abi is nested and not the top level element of the json
let contract = try web3 . eth . Contract ( json : contractJsonABI , abiKey : nil , address : contractAddress )

print ( contract . methods . count )

// Get balance of some address
firstly {
    try contract [ " balanceOf " ] ! ( EthereumAddress ( hex : " 0x3edB3b95DDe29580FFC04b46A68a31dD46106a4a " , eip55 : true ) ) . call ( )
} . done { outputs in
    print ( outputs [ " _balance " ] as? BigUInt )
} . catch { error in
    print ( error )
}

// Send some tokens to another address (locally signing the transaction)
let myPrivateKey = try EthereumPrivateKey ( hexPrivateKey : " ... " )
guard let transaction = contract [ " transfer " ] ? ( EthereumAddress . testAddress , BigUInt ( 100000 ) ) . createTransaction (
    nonce : 0 ,
    gasPrice : EthereumQuantity ( quantity : 21 . gwei ) ,
    maxFeePerGas : nil ,
    maxPriorityFeePerGas : nil ,
    gasLimit : 150000 ,
    from : myPrivateKey . address ,
    value : 0 ,
    accessList : [ : ] ,
    transactionType : . legacy
) ) else {
    return
}
let signedTx = try transaction . sign ( with : myPrivateKey )

firstly {
    web3 . eth . sendRawTransaction ( transaction : signedTx )
} . done { txHash in
    print ( txHash )
} . catch { error in
    print ( error )
}

Mit dieser API können Sie mit jedem intelligenten Vertrag im Ethereum -Netzwerk interagieren!

Weitere Beispiele, einschließlich Vertragserstellung (Konstruktoraufruf), finden Sie unsere Tests.

Häufige Fehler

Konnte ABI -Objekt nicht analysieren

Wenn Sie diesen Fehler erhalten, wenn Sie Ihren ABI von einem JSON analysieren, kann dies daran liegen, dass Ihr Vertrag eine Fallback -Funktion hat. Um es zu lösen, entfernen Sie das Fragment Ihres ABI, das die Informationen über die Fallback -Funktion enthält. Der Teil, den Sie entfernen sollten, könnte so aussehen:

 {
    "payable": false,
    "stateMutability": "nonpayable",
    "type": "fallback"
},

Haftungsausschluss

Bis wir die Version 1.0.0 erreichen, unterliegt unsere API den Bruchänderungen zwischen den Sprüngen der kleinen Versions. Dies soll sicherstellen, dass wir uns darauf konzentrieren können, die beste Implementierung zu liefern, während wir uns in einer starken Entwicklung befinden, anstatt zu versuchen, etwas zu erhalten, das veraltet ist.

Davon abgesehen werden wir versuchen, die Veränderungen zu minimieren. Mit Sicherheit wird es nicht viele geben.

Autor

Die tollen Jungs bei Boilertalk ⚗️
... und noch mehr großartige Mitglieder aus der Community?

In der Liste der Mitwirkenden finden Sie eine vollständige Liste.

Lizenz

Web3 ist unter der MIT -Lizenz verfügbar. Weitere Informationen finden Sie in der Lizenzdatei.