Comment utiliser PHP pour développer des applications à l'aide de la bibliothèque de portefeuille Bitcoin Coinbase (étapes détaillées)

Le contenu de cet article explique comment utiliser la bibliothèque de portefeuille Bitcoin Coinbase pour développer des applications en PHP (étapes détaillées). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. .

Il s'agit de la bibliothèque client officielle de l'API Coinbase Wallet v2. Nous fournissons une interface intuitive et stable pour intégrer Coinbase Wallet dans votre projet PHP.

Important : étant donné que cette bibliothèque cible la nouvelle API v2, les autorisations v2 sont requises (c'est-à-dire wallet:accounts:read). Si vous utilisez toujours la v1, veuillez utiliser une ancienne version de cette bibliothèque.

Installer

Utilisez Composer pour installer la bibliothèque. Si vous n'êtes pas familier avec Composer ou le gestionnaire de dépendances, veuillez lire la documentation de Composer.

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

Authentification

Clé API

Utilisez les clés API et les clés pour accéder à votre propre compte Coinbase.

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

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

OAuth2

Utilisez l'authentification OAuth2 pour accéder à des comptes d'utilisateurs autres que le vôtre. Cette bibliothèque ne gère pas le processus d'établissement de liaison et suppose que vous disposez du jeton d'accès au moment de l'initialisation. Vous pouvez utiliser un client OAuth2 (tel que league/oauth2-client) pour gérer le processus de prise de contact.

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);

Authentification à deux facteurs

Le point de terminaison Send Funds nécessite un jeton 2FA dans certains cas (en savoir plus ici). Lève une exception spécifique si nécessaire.

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',
    ]);
}

Pagination

Plusieurs points de terminaison sont paginés. Par défaut, la bibliothèque récupère uniquement la première page de données pour une requête donnée. Vous pouvez facilement charger plus que la première page de résultats.

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

Vous pouvez également utiliser le paramètre fetch_all pour que la bibliothèque fasse toutes les requêtes nécessaires au chargement de la collection complète.

use Coinbase\Wallet\Enum\Param;

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

AVERTISSEMENT

Il est sage de tenir compte des avertissements. Si un enregistreur PSR-3 standard est configuré, la bibliothèque enregistrera tous les avertissements.

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

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

Référence de ressource

Dans certains cas, l'API renverra une référence de ressource à la place de l'objet de ressource étendu. Ces références peuvent être étendues par rafraîchissement.

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

Vous pouvez également utiliser l'API de requête de paramètre expand pour renvoyer des ressources étendues dans la requête initiale.

use Coinbase\Wallet\Enum\Param;

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

Vous pouvez utiliser des références de ressources lors de la création de nouvelles ressources, évitant ainsi la surcharge liée à la demande de ressources à l'API.

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
]);

Réponse

Il existe plusieurs façons d'accéder aux données brutes de réponse. Premièrement, chaque objet ressource possède une méthode getRawData() que vous pouvez utiliser pour accéder à tous les champs qui ne sont pas mappés aux propriétés de l'objet.

$data = $deposit->getRawData();

Les données brutes de la dernière réponse HTTP sont également disponibles sur l'objet client.

$data = $client->decodeLastResponse();

Méthodes d'enregistrement d'activité

La bibliothèque inclut la prise en charge de la méthode d'enregistrement d'activité sur les objets ressources. Vous devez activer cette fonctionnalité lors du démarrage de l'application.

$client->enableActiveRecord();

Lorsque cette option est activée, vous pouvez appeler des méthodes d'enregistrement actives sur les objets ressources.

use Coinbase\Wallet\Enum\Param;

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

Utilisation

Ceci n'est pas destiné à fournir une documentation complète de l'API. Consultez la documentation officielle pour plus de détails.

Données de marché

Liste des devises locales prises en charge

$currencies = $client->getCurrencies();

Liste des taux de change

$rates = $client->getExchangeRates();

Prix d'achat

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

Prix ​​de vente

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

Prix spot

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

Heure actuelle du serveur

$time = $client->getTime();

Utilisateur

Obtenir les informations d'autorisation

$auth = $client->getCurrentAuthorization();

Rechercher des informations sur l'utilisateur

$auth = $client->getCurrentAuthorization();

Obtenir l'utilisateur actuel

$user = $client->getCurrentUser();

Mettre à jour l'utilisateur actuel

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

Compte

Répertorier tous les comptes

$accounts = $client->getAccounts();

Liste des détails du compte

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

Liste des détails du compte principal

$account = $client->getPrimaryAccount();

Définir le compte comme principal

$client->setPrimaryAccount($account);

Créer un nouveau Bitcoin compte

use Coinbase\Wallet\Resource\Account;

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

Mettre à jour le compte

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

Supprimer le compte

$client->deleteAccount($account);

Adresse

Liste l'adresse de réception du compte

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

Obtenir les informations sur l'adresse de réception

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

Répertorier les transactions de l'adresse

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

Créer une nouvelle adresse de réception

use Coinbase\Wallet\Resource\Address;

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

Transactions

Répertorier les transactions

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

Obtenir des informations sur les transactions

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

Envoyer des fonds

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(); 
}

Transférer des fonds vers un nouveau compte

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);

Demande de fonds

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);

Renvoyer la demande

$account->resendTransaction($transaction);

Annuler la demande

$account->cancelTransaction($transaction);

Terminer la demande

$account->completeTransaction($transaction);

Acheter

Liste des achats

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

Obtenir des informations d'achat

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

Acheter du Bitcoin

use Coinbase\Wallet\Resource\Buy;

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

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

Confirmation d'achat

Il vous suffit de faites-le si vous passez commit=false lors de la création de l'achat.

use Coinbase\Wallet\Enum\Param;

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

Vendre

Liste de vente

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

Obtenir des informations sur la vente

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

Vendre du Bitcoin

use Coinbase\Wallet\Resource\Sell;

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

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

Confirmation de vente

Vous ne devez le faire que si vous réussissez commit=false lors de la création de la vente.

use Coinbase\Wallet\Enum\Param;

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

Dépôt

Liste de la liste des dépôts

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

Obtenir des informations sur les dépôts

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

Dépôt

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);

Soumettre le dépôt

Vous ne devez le faire que si vous réussissez commit=false lors de la création du dépôt.

use Coinbase\Wallet\Enum\Param;

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

Retrait

Liste des ordres de retrait

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

Annuler

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

Retrait

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);

Soumettre Sortie

Ceci n'est nécessaire que si vous réussissez commit=true lors de l'appel de la méthode de retrait.

use Coinbase\Wallet\Enum\Param;

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

Modes de paiement

Liste des modes de paiement

$paymentMethods = $client->getPaymentMethods();

Obtenir les modes de paiement

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

Marchand

Obtenir le marchand

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

Commander

Liste de la commande

$orders = $client->getOrders();

Obtenir la commande

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

Créer la commande

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

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

$client->createOrder($order);

Remboursement Commander

use Coinbase\Wallet\Enum\CurrencyCode;

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

Paiement

Liste du paiement

$checkouts = $client->getCheckouts();

Créer un paiement

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";

Paiement

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

Obtenir commande de paiement

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

Créer une commande de paiement

$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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!