So verwenden Sie die Wallet-Bibliothek Bitcoin Coinbase, um Anwendungen mit PHP zu entwickeln (detaillierte Schritte)

Der Inhalt dieses Artikels befasst sich mit der Verwendung der Bitcoin-Coinbase-Wallet-Bibliothek zur Entwicklung von Anwendungen in PHP (detaillierte Schritte). Ich hoffe, dass er für Sie hilfreich ist .

Dies ist die offizielle Client-Bibliothek für Coinbase Wallet API v2. Wir bieten eine intuitive und stabile Schnittstelle zur Integration von Coinbase Wallet in Ihr PHP-Projekt.

Wichtig: Da diese Bibliothek auf die neuere API v2 abzielt, sind v2-Berechtigungen erforderlich (d. h. wallet:accounts:read). Wenn Sie noch v1 verwenden, verwenden Sie bitte eine ältere Version dieser Bibliothek.

Installieren

Verwenden Sie Composer, um die Bibliothek zu installieren. Wenn Sie mit Composer oder dem Abhängigkeitsmanager nicht vertraut sind, lesen Sie bitte die Composer-Dokumentation.

"require": {
    "coinbase/coinbase": "~2.0"
}

Authentifizierung

API-Schlüssel

Verwenden Sie API-Schlüssel und Geheimnisse, um auf Ihr eigenes Coinbase-Konto zuzugreifen.

use Coinbase\Wallet\Client;
use Coinbase\Wallet\Configuration;

$configuration = Configuration::apiKey($apiKey, $apiSecret);
$client = Client::create($configuration);

OAuth2

Verwenden Sie die OAuth2-Authentifizierung, um auf andere Benutzerkonten als Ihre eigenen zuzugreifen. Diese Bibliothek übernimmt den Handshake-Prozess nicht und geht davon aus, dass Sie zum Zeitpunkt der Initialisierung über das Zugriffstoken verfügen. Sie können einen OAuth2-Client (z. B. league/oauth2-client) verwenden, um den Handshake-Prozess abzuwickeln.

use Coinbase\Wallet\Client;
use Coinbase\Wallet\Configuration;

// with a refresh token
$configuration = Configuration::oauth($accessToken, $refreshToken);

// without a refresh token
$configuration = Configuration::oauth($accessToken);

$client = Client::create($configuration);

Zwei-Faktor-Authentifizierung

Der Endpunkt „Geld senden“ erfordert in einigen Fällen ein 2FA-Token (mehr erfahren Sie hier). Löst bei Bedarf eine bestimmte Ausnahme aus.

use Coinbase\Wallet\Enum\Param;
use Coinbase\Wallet\Exception\TwoFactorRequiredException;
use Coinbase\Wallet\Resource\Transaction;

$transaction = Transaction::send([
    'toEmail' => 'test@test.com',
    'bitcoinAmount' => 1
]);

$account = $client->getPrimaryAccount();
try {
    $client->createAccountTransaction($account, $transaction);
} catch (TwoFactorRequiredException $e) {
    // show 2FA dialog to user and collect 2FA token

    // retry call with token
    $client->createAccountTransaction($account, $transaction, [
        Param::TWO_FACTOR_TOKEN => '123456',
    ]);
}

Paginierung

Mehrere Endpunkte sind paginiert. Standardmäßig ruft die Bibliothek nur die erste Datenseite für eine bestimmte Anfrage ab. Sie können problemlos mehr als nur die erste Ergebnisseite laden.

$transactions = $client->getAccountTransactions($account);
while ($transactions->hasNextPage()) {
    $client->loadNextTransactions($transactions);
}

Sie können auch den Parameter fetch_all verwenden, damit die Bibliothek alle erforderlichen Anforderungen zum Laden der gesamten Sammlung stellt.

use Coinbase\Wallet\Enum\Param;

$transactions = $client->getAccountTransactions($account, [
    Param::FETCH_ALL => true,
]);

WARNUNG

Es ist ratsam, die Warnungen zu beachten. Wenn ein Standard-PSR-3-Logger konfiguriert ist, protokolliert die Bibliothek alle Warnungen.

use Coinbase\Wallet\Client;
use Coinbase\Wallet\Configuration;

$configuration = Configuration::apiKey($apiKey, $apiSecret);
$configuration->setLogger($logger);
$client = Client::create($configuration);

Ressourcenreferenz

In einigen Fällen gibt die API eine Ressourcenreferenz anstelle des erweiterten Ressourcenobjekts zurück. Diese Referenzen können durch Auffrischen erweitert werden.

$deposit = $this->client->getAccountDeposit($account, $depositId);
$transaction = $deposit->getTransaction();
if (!$transaction->isExpanded()) {
    $this->client->refreshTransaction($transaction);
}

Sie können auch die Parameteranforderungs-API expand verwenden, um erweiterte Ressourcen in der ersten Anforderung zurückzugeben.

use Coinbase\Wallet\Enum\Param;

$deposit = $this->client->getAccountDeposit($account, $depositId, [
    Param::EXPAND = ['transaction'],
]);

Sie können beim Erstellen neuer Ressourcen Ressourcenreferenzen verwenden und so den Mehraufwand beim Anfordern von Ressourcen über die API vermeiden.

use Coinbase\Wallet\Resource\Deposit;
use Coinbase\Wallet\Resource\PaymentMethod;

$deposit = new Deposit([
    'paymentMethod' => PaymentMethod::reference($paymentMethodId)
]);

// or use the convenience method
$deposit = new Deposit([
    'paymentMethodId' => $paymentMethodId
]);

Antwort

Es gibt mehrere Möglichkeiten, auf die rohen Antwortdaten zuzugreifen. Erstens verfügt jedes Ressourcenobjekt über eine getRawData()-Methode, mit der Sie auf alle Felder zugreifen können, die nicht Objekteigenschaften zugeordnet sind.

$data = $deposit->getRawData();

Die Rohdaten der letzten HTTP-Antwort sind auch auf dem Client-Objekt verfügbar.

$data = $client->decodeLastResponse();

Methoden zur Aktivitätsaufzeichnung

Diese Bibliothek bietet Unterstützung für die Aktivitätsaufzeichnungsmethode für Ressourcenobjekte. Sie müssen diese Funktion beim Booten der Anwendung aktivieren.

$client->enableActiveRecord();

Wenn diese Option aktiviert ist, können Sie aktive Aufzeichnungsmethoden für Ressourcenobjekte aufrufen.

use Coinbase\Wallet\Enum\Param;

$transactions = $account->getTransactions([
    Param::FETCH_ALL => true,
]);

Verwendung

Dies ist nicht als vollständige Dokumentation der API gedacht. Weitere Einzelheiten finden Sie in der offiziellen Dokumentation.

Marktdaten

Unterstützte lokale Währungen auflisten

$currencies = $client->getCurrencies();

Wechselkurse auflisten

$rates = $client->getExchangeRates();

Kaufpreis

$buyPrice = $client->getBuyPrice('BTC-USD');

Verkaufspreis

$sellPrice = $client->getSellPrice('BTC-USD');

Spotpreis

$spotPrice = $client->getSpotPrice('BTC-USD');

Aktuelle Serverzeit

$time = $client->getTime();

Benutzer

Autorisierungsinformationen abrufen

$auth = $client->getCurrentAuthorization();

Benutzerinformationen finden

$auth = $client->getCurrentAuthorization();

Abrufen Aktueller Benutzer

$user = $client->getCurrentUser();

Aktuellen Benutzer aktualisieren

$user->setName('New Name');
$client->updateCurrentUser($user);

Konten

Alle Konten auflisten

$accounts = $client->getAccounts();

Kontodetails auflisten

$account = $client->getAccount($accountId);

Primäre Kontodetails auflisten

$account = $client->getPrimaryAccount();

Konto zum primären Konto machen

$client->setPrimaryAccount($account);

Neues Bitcoin-Konto erstellen

use Coinbase\Wallet\Resource\Account;

$account = new Account([
    'name' => 'New Account'
]);
$client->createAccount($account);

Konto aktualisieren

$account->setName('New Account Name');
$client->updateAccount($account):

Konto löschen

$client->deleteAccount($account);

Adresse

Empfangsadresse des Kontos auflisten

$addresses = $client->getAccountAddresses($account);

Informationen zur Empfangsadresse abrufen

$address = $client->getAccountAddress($account, $addressId);

Transaktion der Adresse auflisten

$transactions = $client->getAddressTransactions($address);

Neue Empfangsadresse erstellen

use Coinbase\Wallet\Resource\Address;

$address = new Address([
    'name' => 'New Address'
]);
$client->createAccountAddress($account, $address);

Transaktion

Transaktionen auflisten

$transactions = $client->getAccountTransactions($account);

Transaktionsinformationen abrufen

$transaction = $client->getAccountTransaction($account, $transactionId);

Geld senden

use Coinbase\Wallet\Enum\CurrencyCode;
use Coinbase\Wallet\Resource\Transaction;
use Coinbase\Wallet\Value\Money;

$transaction = Transaction::send([
    'toBitcoinAddress' => 'ADDRESS',
    'amount'           => new Money(5, CurrencyCode::USD),
    'description'      => 'Your first bitcoin!',
    'fee'              => '0.0001' // only required for transactions under BTC0.0001
]);

try { $client->createAccountTransaction($account, $transaction); }
catch(Exception $e) {
     echo $e->getMessage(); 
}

Geld auf neues Konto überweisen

use Coinbase\Wallet\Resource\Transaction;
use Coinbase\Wallet\Resource\Account;

$fromAccount = Account::reference($accountId);

$toAccount = new Account([
    'name' => 'New Account'
]);
$client->createAccount($toAccount);

$transaction = Transaction::transfer([
    'to'            => $toAccount,
    'bitcoinAmount' => 1,
    'description'   => 'Your first bitcoin!'
]);

$client->createAccountTransaction($fromAccount, $transaction);

Geld anfordern

use Coinbase\Wallet\Enum\CurrencyCode;
use Coinbase\Wallet\Resource\Transaction;
use Coinbase\Wallet\Value\Money;

$transaction = Transaction::request([
    'amount'      => new Money(8, CurrencyCode::USD),
    'description' => 'Burrito'
]);

$client->createAccountTransaction($transaction);

Anfrage erneut senden

$account->resendTransaction($transaction);

Anfrage abbrechen

$account->cancelTransaction($transaction);

Anfrage abschließen

$account->completeTransaction($transaction);

Kaufen

Käufe auflisten

$buys = $client->getAccountBuys($account);

Kaufinformationen abrufen

$buy = $client->getAccountBuy($account, $buyId);

Bitcoin kaufen

use Coinbase\Wallet\Resource\Buy;

$buy = new Buy([
    'bitcoinAmount' => 1
]);

$client->createAccountBuy($account, $buy);

Kaufbestätigung

Sie müssen dies nur tun, wenn Sie commit=false beim Erstellen des Kaufs bestehen.

use Coinbase\Wallet\Enum\Param;

$client->createAccountBuy($account, $buy, [Param::COMMIT => false]);
$client->commitBuy($buy);

Verkaufen

Verkaufsliste

$sells = $client->getAccountSells($account);

Verkaufsinformationen abrufen

$sell = $client->getAccountSell($account, $sellId);

Bitcoin verkaufen

use Coinbase\Wallet\Resource\Sell;

$sell = new Sell([
    'bitcoinAmount' => 1
]);

$client->createAccountSell($account, $sell);

Verkaufsbestätigung

Sie müssen dies nur tun, wenn Sie beim Erstellen des Verkaufs commit=false übergeben.

use Coinbase\Wallet\Enum\Param;

$client->createAccountSell($account, $sell, [Param::COMMIT => false]);
$client->commitSell($sell);

Einzahlung

Einzahlungsliste auflisten

$deposits = $client->getAccountDeposits($account);

Einzahlungsinformationen abrufen

$deposit = $client->getAccountDeposit($account, $depositId);

Einzahlung

use Coinbase\Wallet\Enum\CurrencyCode;
use Coinbase\Wallet\Resource\Deposit;
use Coinbase\Wallet\Value\Money;

$deposit = new Deposit([
    'amount' => new Money(10, CurrencyCode::USD)
]);

$client->createAccountDeposit($account, $deposit);

Einzahlung übermitteln

Sie müssen dies nur tun, wenn Sie beim Erstellen der Einzahlung commit=false übergeben.

use Coinbase\Wallet\Enum\Param;

$client->createAccountDeposit($account, $deposit, [Param::COMMIT => false]);
$client->commitDeposit($deposit);

Auszahlung

Auszahlungsauftrag auflisten

$withdrawals = $client->getAccountWithdrawals($account);

Stornieren

$withdrawal = $client->getAccountWithdrawal($account, $withdrawalId);

Auszahlung

use Coinbase\Wallet\Enum\CurrencyCode;
use Coinbase\Wallet\Resource\Withdrawal;
use Coinbase\Wallet\Value\Money;

$withdrawal = new Withdrawal([
    'amount' => new Money(10, CurrencyCode::USD)
]);

$client->createAccountWithdrawal($account, $withdrawal);

Senden zum Beenden

Sie Sie müssen dies nur tun, wenn Sie beim Aufruf der Auszahlungsmethode commit=true übergeben.

use Coinbase\Wallet\Enum\Param;

$client->createAccountWithdrawal($account, $withdrawal, [Param::COMMIT => false]);
$client->commitWithdrawal($withdrawal);

Zahlungsmethoden

Zahlungsmethoden auflisten

$paymentMethods = $client->getPaymentMethods();

Zahlungsmethoden abrufen

$paymentMethod = $client->getPaymentMethod($paymentMethodId);

Händler

Händler abrufen

$merchant = $client->getMerchant($merchantId);

Bestellungen

Bestellungen auflisten

$orders = $client->getOrders();

Bestellungen erhalten

$order = $client->getOrder($orderId);

Bestellungen erstellen

use Coinbase\Wallet\Resource\Order;
use Coinbase\Wallet\Value\Money;

$order = new Order([
    'name' => 'Order #1234',
    'amount' => Money::btc(1)
]);

$client->createOrder($order);

Bestellungen erstatten

use Coinbase\Wallet\Enum\CurrencyCode;

$client->refundOrder($order, CurrencyCode::BTC);

Zur Kasse gehen

Kaufliste auflisten

$checkouts = $client->getCheckouts();

Kasse erstellen

use Coinbase\Wallet\Resource\Checkout;

$params = array(
    'name'               => 'My Order',
    'amount'             => new Money(100, 'USD'),
    'metadata'           => array( 'order_id' => $custom_order_id )
);

$checkout = new Checkout($params);
$client->createCheckout($checkout);
$code = $checkout->getEmbedCode();
$redirect_url = "https://www.coinbase.com/checkouts/$code";

Kasse

$checkout = $client->getCheckout($checkoutId);

Bestellungen zur Kasse erhalten

$orders = $client->getCheckoutOrders($checkout);

Kasse erstellen Kontobestellung

$order = $client->createNewCheckoutOrder($checkout);

通知webhook和验证

$raw_body = file_get_contents('php://input');
$signature = $_SERVER['HTTP_CB_SIGNATURE'];
$authenticity = $client->verifyCallback($raw_body, $signature); // boolean

贡献和测试

测试套件使用PHPUnit构建。通过运行phpunit命令运行单元测试套件。

phpunit

还有一组集成测试，它们向API发出实际请求并检查生成的对象。要运行这些测试，必须将phpunit.xml.dist复制到phpunit.xml，为CB_API_KEY和CB_API_SECRET变量提供值，并在运行测试套件时指定integration组。

phpunit --group integration

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Wallet-Bibliothek Bitcoin Coinbase, um Anwendungen mit PHP zu entwickeln (detaillierte Schritte). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!