developed with ❤️ by chainside

This project is the official SDK library for the integration with the Chainside Pay Platform. It is an extension of the sdk-boilerplate library.

Follow these steps to install the SDK library into your system:

composer require chainside\webpos-sdk

Then include it in your script:

<?php

require_once '/path/to/vendor/autoload.php';

// ... use the library

For Laravel 5.5+ there is non need to do any further step since the package uses the Laravel Autodiscovery Feature.

For Laravel 5.4 and below you need to follow these steps:

Include the Service Provider in your config/app.php file under the key providers

<?php

/* config/app.php */

// ...

'providers' => [
    // ...
    Chainside\SDK\WebPos\Laravel\ChainsideWebPosSdkServiceProvider::class
],

Optional: include the Facade in your config/app.php file under the key aliases

<?php

/* config/app.php */

// ...

'aliases' => [
    // ...
    'ChainsideWebPosClient' => Chainside\SDK\WebPos\Laravel\Facades\Client::class,
    'ChainsideWebPosCallbackHandler' => Chainside\SDK\WebPos\Laravel\Facades\CallbackHandler::class,
],

The following sections will describe the high level structure of the SDK library.

In order to be able to configure your SDK client you have to set some configuration parameters. Here is the list of the configuration parameters used by the library:

To customize the HTTP client configuration please see the Guzzle Docs

By default, the SDK library uses a file cache as caching system. You can specify a different file location by changing the cache_directory config variable.

NOTE: When using the library with Laravel, the sdk will automatically use the caching driver specified in the Laravel configuration.

The Library exposes a client object which is instantiated with the system configuration and provides an high-level interface to send requests. Client's instances take care of compiling and sending http request and parse responses into SdkObject instances.

The library defines an SdkObject class which is extended by actual objects which represent Chainside-Pay API requests and response bodies. Every json object defined in the API has a corresponding SdkObject class which is either the input of a client instance method (for creation) or returned (for reading)

Callbacks are requests sent by the server to your application in order to notify about some events. Every callback is sent only to HTTPS webhooks and will be securely signed by the server in order to be verified.

The following sections will describe how to use the SDK library and all the detail needed to integrate your business with Chainside Pay.

In order to communicate with our backend first you need to instantiate the client:

<?php

use Chainside\SDK\WebPos\Client;

$config = [
    'mode' => 'live',
    'client_id' => 'CLIENT_ID',
    'secret' => 'SECRET'
];

$client = new Client($config);

or if running in Laravel:

<?php

// Using the IoC
$client = app('chaniside.sdk.webpos');

// Using the Facade, you can directly instantiate run an action

$response = \ChainsideWebPosClient::clientCredentialsLogin(...);

Once the client is instantiated and configured, you can use the following methods to send requests:

Callback list object

Callback Retrieval object

Payment order retrieval data

Bitcoin transaction paying a payment order

Transaction's output

Data describing the current state of a payment order

Cryto and fiat paid amounts

Data of payment order's creator

Deposit account lite object when sent nested in other api objects

Rate Data

Currency Data

Callback's trigger request body

Payment order deletion response

List of Business' payment orders

Data required to create a new payment order

Response data for a payment order creation request

Data required to perform a confidential client login

Response data for a login performed by a confidential client.

Payment order retrieval data

Chainside will send callbacks if some event is triggered regarding one of your assets registered on the Business Panel. Our server will send a request to your webhooks that you need to parse and verify. You can do this using this SDK library in the following way:

<?php

use Chainside\SDK\WebPos\ChainsideCallbacksHandler;

$config = [
    'mode' => 'live',
    'client_id' => 'CLIENT_ID',
    'secret' => 'SECRET'
];

$context = new ApiContext($config);
$handler = new ChainsideCallbacksHandler($context);

$headers = $request->getHeaders();
$body = $request->getRawBody();

$receivedCallback = $handler->parse($headers, $body);

The ChainsideCallbacksHandler will verify and parse the callback automatically from the incoming request.

If you are using Laravel you can use the facade to access the callback handler:

<?php

$receivedCallback = \ChainsideWebPosCallbackHandler::parse($headers, $request);

// Or using the IoC
// $receivedCallback = app('chainside.sdk.webpos.callback.handler')->parse($headers, $request);

Alternatively you can use the parseFromGlobals method to automatically retrieve the request headers and the raw body from the PHP HTTP global variables:

<?php

$context = new ApiContext($config);
$handler = new ChainsideCallbacksHandler($context);

$receivedCallback = $handler->parseFromGlobals();

// Or, using Laravel

$receivedCallback = \ChainsideWebPosCallbackHandler::parseFromGlobals();

In order to maintain consistency between our backend and our SDKs, contributing through pull requests is highly discouraged. Consider posting an issue if you need to signal any problem with this library.

In case of a discovery of an actual or potential security issue please contact us at [email protected]