README

Installation

Install the library using Composer. Please read the Composer Documentation if you are unfamiliar with Composer or dependency managers in general.

composer require galal/coinbase

Provider => Galal\Coinbase\CoinbaseServiceProvider::class,

Aliase => 'Coinbase'=>Galal\Coinbase\Facades\Coinbase::class,

To get started, you'll need to publish all vendor assets:

$ php artisan vendor:publish

Authentication

API Key

Add an API key and secret of your own Coinbase account to config/coinbase.php .

use Galal\Coinbase\Facades\Coinbase;

$client = Coinbase::client();

OAuth2

Use OAuth2 authentication to access a user's account other than your own. This library does not handle the handshake process, and assumes you have an access token when it's initialized. You can handle the handshake process using an [OAuth2 client] such as [league/oauth2-client].

use Galal\Coinbase\Facades\Coinbase;

// with a refresh token
$client = Coinbase::clientUsingOauth($accessToken, $refreshToken);

// without a refresh token
$client = Coinbase::clientUsingOauth($accessToken);

Two factor authentication

The send money endpoint requires a 2FA token in certain situations . A specific exception is thrown when this is required.

use Galal\Coinbase\Facades\Coinbase;

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

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

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

Warnings

It's prudent to be conscious of warnings. The library will log all warnings to a standard PSR-3 logger if one is configured.

use Galal\Coinbase\Facades\Coinbase;

$client = Coinbase::clientWithLogging($logger);

You can also request that the API return an expanded resource in the initial request by using the expand parameter.

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

Resource references can be used when creating new resources, avoiding the overhead of requesting a resource from the API.

$deposit = Coinbase::deposit([
    'paymentMethod' => Coinbase::paymentMethod()->reference($paymentMethodId)
]);

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

Responses

There are multiple ways to access raw response data. First, each resource object has a getRawData() method which you can use to access any field that are not mapped to the object properties.

$data = $deposit->getRawData();

Raw data from the last HTTP response is also available on the client object.

$data = $client->decodeLastResponse();

Active record methods

The library includes support for active record methods on resource objects. You must enable this functionality when bootstrapping your application.

$client->enableActiveRecord();

Once enabled, you can call active record methods on resource objects.

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

Usage

List supported native currencies

$currencies = $client->getCurrencies();

List exchange rates

$rates = $client->getExchangeRates();

Buy price

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

Sell price

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

Spot price

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

Current server time

$time = $client->getTime();

Get authorization info

$auth = $client->getCurrentAuthorization();

Lookup user info

$user = $client->getUser($userId);

Get current user

$user = $client->getCurrentUser();

Update current user

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

List all accounts

$accounts = $client->getAccounts();

List account details

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

List primary account details

$account = $client->getPrimaryAccount();

Set account as primary

$client->setPrimaryAccount($account);

Create a new bitcoin account

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

Update an account

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

Delete an account

$client->deleteAccount($account);

List receive addresses for account

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

Get receive address info

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

List transactions for address

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

Create a new receive address

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

List transactions

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

Get transaction info

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

Send funds

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

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

Transfer funds to a new account

$fromAccount = Coinbase::account()->reference($accountId);

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

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

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

Request funds

$transaction = Coinbase::transaction()->request([
    'amount'      => Coinbase::money(8, CurrencyCode::USD),
    'description' => 'Burrito'
]);

$client->createAccountTransaction($transaction);

Resend request

$account->resendTransaction($transaction);

Cancel request

$account->cancelTransaction($transaction);

Fulfill request

$account->completeTransaction($transaction);

List buys

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

Get buy info

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

Buy bitcoins

$buy = Coinbase::buy([
    'bitcoinAmount' => 1
]);

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

Commit a buy

You only need to do this if you pass commit=false when you create the buy.

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

List sells

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

Get sell info

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

Sell bitcoins

$sell = Coinbase::sell([
    'bitcoinAmount' => 1
]);

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

Commit a sell

You only need to do this if you pass commit=false when you create the sell.

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

List deposits

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

Get deposit info

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

Deposit funds

$deposit = Coinbase::deposit([
    'amount' => Coinbase::money(10, Coinbase::currencyCode()::USD)
]);

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

Commit a deposit

You only need to do this if you pass commit=false when you create the deposit.

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

List withdrawals

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

Get withdrawal

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

Withdraw funds

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

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

Commit a withdrawal

You only need to do this if you pass commit=true when you call the withdrawal method.

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

List payment methods

$paymentMethods = $client->getPaymentMethods();

Get payment method

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

Get merchant

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

List orders

$orders = $client->getOrders();

Get order

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

Create order

$order = Coinbase::order([
    'name' => 'Order #1234',
    'amount' => Coinbase::moneyBTC(1)
]);

$client->createOrder($order);

Refund order

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

Checkouts

List checkouts

$checkouts = $client->getCheckouts();

Create checkout

$params = array(
    'name'               => 'My Order',
    'amount'             => Coinbase::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";

Get checkout

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

Get checkout's orders

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

Create order for checkout

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

galal / coinbase

Maintainers

Details