omisego 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e412321f89fdea170297609ad78394e545fb6cd
-  data.tar.gz: b88bee3f72a6a7908248af51fdc7c2158f8d5968
+  metadata.gz: eafb5f2c0b3e507ea7b9aa3675680ee463ebd0c8
+  data.tar.gz: ea58112e49815ae59d9f3d662ecf66a066e16030
 SHA512:
-  metadata.gz: 8854f32fb7f1f1d1ea34c78b932e17829eb8b92d26da2aec3bd386c722214ec2cc29310812e2d5afd71f6e046f0fdeb86d7925bb1a1eb368d76a5abf79cb44c7
-  data.tar.gz: 9d7c270203b2e0e403ca1668022f8c2937a6fd88c581f44365006a9cd6fa4b8a2cb643d095535603c0c0f7a4f5489224d9dafac06143ab465ebca53dd56f7a2a
+  metadata.gz: 8cbc20bbda02d54785ee599541d399e167d99c38f30d5d246b54a5f47b66a21547ea138cece0165d4eed028c3f3be803918e42bfa1d5fd3d0bd90f68bf6c3486
+  data.tar.gz: c6ec802a82a4b0ebaa62453b0fdbdbe48b0be1127b495961604febc53da2c892cf6426a8f19b8c471c5a42bc3e59f9544b0fcc23f40b97d9ce9763c739aaf86d

data/README.md

@@ -6,7 +6,7 @@
 
 OmiseGO is a Ruby SDK meant to communicate with an OmiseGO eWallet setup.
 
-For more details about the web API being wrapped by this SDK, take a look at the [OpenAPI Specification](https://ewallet.demo.omisego.io/api/docs.ui). You are free to use that web API directly if you prefer, this SDK is only provided as a convenient way to make those HTTP calls and return Ruby objects as responses.
+For more details about the web API being wrapped by this SDK, take a look at the [OpenAPI Specification](https://ewallet.demo.omisego.io/api/admin/docs.ui). You are free to use that web API directly if you prefer, this SDK is only provided as a convenient way to make those HTTP calls and return Ruby objects as responses.
 
 ## Installation
 
@@ -104,14 +104,38 @@ All the calls below will communicate with the OmiseGO wallet specified in the `b
 __The method `#error?` can be used on any model to check if it's an error or a valid result.__
 
 
+### Using the API directly
+
+Almost all the calls presented in the [API documentation](https://ewallet.demo.omisego.io/api/admin/docs.ui) can be accessed from this Ruby SDK as a provider. A lof ot the endpoints are, however, not fully supported yet. If you wish to use an endpoint not supported by the SDK, you can do the following:
+
+```ruby
+client = Client.new # Will use global configuration
+
+response = client.request.send({
+  "account.get_wallets",
+  {
+    id: "acc_123"
+  }, # body
+})
+```
+
+`response` will contain the full payload returned from the server, where the `data` field contains the actual response data.
+
 ### Understanding Idempotency
 
 Some of the calls in the web API (and in the methods below) contain a parameter called `idempotency_token`.
 
 ### Understanding wallet types
 
+Not all wallets are created equals. We have 3 different types of wallets:
+
+- `primary`: Only one primary wallet per account or user is allowed. This is the default used if you don't want to deal with wallets.
+- `secondary`: An additional wallet that can be created if you need to keep separate balances.
+- `burn`: A special type of wallets where value goes and never comes back. If you want to get rid of tokens (remove them from circulation), send them to a `burn` wallet. Accounts get one created by default, and more can be created if needed.
+
 ### Understanding Metadata and Encrypted Metadata
 
+`metadata` and `encrypted_metadata` are fields you can use to store any kind of data. Formatted as dictionnaries (json/map/hash), they are stored in the database with the referenced record. `encrypted_metadata` will be encrypted and not readable directly from a dump of the DB without the key, while `metadata` are stored in clear (and will potentially be searchable later).
 
 ### All available methods
 
@@ -316,7 +340,7 @@ Returns either:
 - An `OmiseGO::List` of `OmiseGO::Wallet` instances (containing the 2 wallets involved in the transaction)
 - An `OmiseGO::Error` instance
 
-### Listing transactions
+### Managing transactions
 
 #### Params
 
@@ -411,6 +435,76 @@ transaction = OmiseGO::Transaction.all(
 
 Since those transactions are already scoped down to the given user, it is NOT POSSIBLE to specify both `from` AND `to` in the `search_terms`. Doing so will result in the API ignoring both of those fields for the search.
 
+#### Creating transactions
+
+Transactions can be created with the `OmiseGO::Transaction.create()` method (which will call the `/transaction.create` endpoint).
+
+Two types of transactions can be made, depending if you intend to exchange tokens or if it's a simple transfer between two addresses.
+
+##### Defining the sender and receiver
+
+There are different ways to define who is supposed to send/receive the tokens. The server expects at least one of these sets of parameters to find the sender:
+
+- `from_provider_user_id`: Will find the user and takes his primary address as the sending address.
+- `from_provider_user_id` + `from_address`: Will find the user and ensures the given `from_address` belongs to him.
+- `from_account_id`: Will find the account and takes its primary address as the sending address.
+- `from_account_id` + `from_address`: Will find the account and ensures the given `from_address` belongs to that account.
+- `from_address`: Will simply set the sending address (and get the owner of that address for reference).
+
+The parameters are the same for the other side, simply swap `from` with `to`.
+
+- `to_provider_user_id`
+- `to_provider_user_id` + `to_address`
+- `to_account_id`
+- `to_account_id` + `to_address`
+- `to_address`
+
+##### Simple Transfer
+
+In addition to the previous parameters, a simple transfer requires to pass:
+
+- `token_id`
+- `amount`
+
+```
+transaction = OmiseGO::Transaction.create({
+  from_address: "abcd111111111111",
+  to_address: "abcd111111111112",
+  token_id: "tok_OMG_01ccmny8yne44b188287d44498",
+  amount: 100
+})
+```
+
+Returns either:
+- An `OmiseGO::Transaction` instance
+- An `OmiseGO::Error` instance
+
+##### Exchange Transfer
+
+Exchange transfers are a bit more complicated. In addition to defining the sender/receiver, you will also need to give it a `from_token_id`/`to_token_id` pair, a `from_amount` OR a `to_amount` and either an `exchange_account_id` OR an `exchange_wallet_address`.
+
+- `from_token_id`: The ID of the sending token.
+- `to_token_id`: The ID of the receive token.
+- `from_amount`: The amount of tokens (`from_token_id`) to send
+- `to_amount`: The amount of tokens (`to_token_id`) to receive
+- `exchange_account_id`: The ID of the account that will be used as an intermediary to exchange funds. The primary wallet of that account needs to have funds in the token identified by `to_token_id`, unless `exchange_wallet_address` is specified.
+- `exchange_wallet_address`: The ID of the wallet that will be used as an intermediary to exchange funds. That wallet needs to have funds in the token identified by `to_token_id`.
+
+```
+OmiseGO::Transaction.create({
+  from_address: "abcd111111111111",
+  to_address: "abcd111111111112",
+  from_token_id: "tok_BTC_01chckv8eh2nq1zwkyfkh2pe40",
+  to_token_id: "tok_ETH_01chckv8h6v355xgh629w4r27c",
+  from_amount: 1,
+  exchange_account_id: "acc_01chckv67se4eddn11nyz7y3ma"
+})
+```
+
+Returns either:
+- An `OmiseGO::Transaction` instance
+- An `OmiseGO::Error` instance
+
 ### Getting settings
 
 #### All

data/lib/omisego/transaction.rb

@@ -1,7 +1,14 @@
 module OmiseGO
   class Transaction < Base
-    attributes :id, :idempotency_token, :from, :to, :exchange,
-               :metadata, :encrypted_metadata, :status, :created_at
+    attributes :id,
+               :idempotency_token,
+               :from,
+               :to,
+               :exchange,
+               :metadata,
+               :encrypted_metadata,
+               :status,
+               :created_at
 
     class << self
       def all(params: {}, client: nil)
@@ -25,17 +32,43 @@ module OmiseGO
 
         request(client).send('user.get_transactions', body, params: params).data
       end
-    end
 
-    def create(from_address:, to_address:, token_id:, amount:, metadata: {}, encrypted_metadata: {})
-      request(client).send('transfer', {
-                             from_address: from_address,
-                             to_address: to_address,
-                             token_id: token_id,
-                             amount: amount,
-                             metadata:  metadata,
-                             encrypted_metadata:  encrypted_metadata
-                           }, params: params).data
+      def create(from_account_id: nil,
+                 from_provider_user_id: nil,
+                 from_address: nil,
+                 to_account_id: nil,
+                 to_provider_user_id: nil,
+                 to_address: nil,
+                 from_token_id: nil,
+                 to_token_id: nil,
+                 token_id: nil,
+                 from_amount: nil,
+                 to_amount: nil,
+                 amount: nil,
+                 exchange_account_id: nil,
+                 exchange_wallet_address: nil,
+                 metadata: {},
+                 encrypted_metadata: {},
+                 idempotency_token:,
+                 client: nil)
+        request(client).send('transaction.create', from_account_id: from_account_id,
+                                                   from_provider_user_id: from_provider_user_id,
+                                                   from_address: from_address,
+                                                   to_account_id: to_account_id,
+                                                   to_provider_user_id: to_provider_user_id,
+                                                   to_address: to_address,
+                                                   from_token_id: from_token_id,
+                                                   to_token_id: to_token_id,
+                                                   token_id: token_id,
+                                                   from_amount: from_amount,
+                                                   to_amount: to_amount,
+                                                   amount: amount,
+                                                   exchange_account_id: exchange_account_id,
+                                                   exchange_wallet_address: exchange_wallet_address,
+                                                   metadata: metadata,
+                                                   encrypted_metadata: encrypted_metadata,
+                                                   idempotency_token: idempotency_token).data
+      end
     end
 
     def from

data/lib/omisego/version.rb

@@ -1,3 +1,3 @@
 module OmiseGO
-  VERSION = '0.11.0'.freeze
+  VERSION = '0.12.0'.freeze
 end

data/lib/omisego/wallet.rb

@@ -9,34 +9,40 @@ module OmiseGO
         request(client).send('user.get_wallets', provider_user_id: provider_user_id).data
       end
 
+      def all_for_account(account_id:, client: nil)
+        request(client).send('account.get_wallets', id: account_id).data
+      end
+
       def credit(provider_user_id:, token_id:, amount:, metadata: {}, user_address: nil,
                  encrypted_metadata: {}, idempotency_token:, account_id:, account_address: nil,
                  client: nil)
-        request(client)
-          .send('user.credit_wallet', provider_user_id: provider_user_id,
-                                      user_address: user_address,
-                                      token_id: token_id,
-                                      amount: amount,
-                                      metadata: metadata,
-                                      encrypted_metadata: encrypted_metadata,
-                                      account_id: account_id,
-                                      account_address: account_address,
-                                      idempotency_token: idempotency_token).data
+        params = { to_provider_user_id: provider_user_id,
+                   to_address: user_address,
+                   from_account_id: account_id,
+                   from_address: account_address,
+                   token_id: token_id,
+                   amount: amount,
+                   metadata: metadata,
+                   encrypted_metadata: encrypted_metadata,
+                   account_address: account_address,
+                   idempotency_token: idempotency_token }
+        request(client).send('transaction.create', params).data
       end
 
       def debit(provider_user_id:, user_address: nil, token_id:, amount:, metadata: {},
                 encrypted_metadata: {}, idempotency_token:, account_id:, account_address: nil,
                 client: nil)
-        request(client)
-          .send('user.debit_wallet', provider_user_id: provider_user_id,
-                                     user_address: user_address,
-                                     token_id: token_id,
-                                     amount: amount,
-                                     metadata: metadata,
-                                     encrypted_metadata: encrypted_metadata,
-                                     account_id: account_id,
-                                     account_address: account_address,
-                                     idempotency_token: idempotency_token).data
+        params = { from_provider_user_id: provider_user_id,
+                   from_address: user_address,
+                   to_account_id: account_id,
+                   to_address: account_address,
+                   token_id: token_id,
+                   amount: amount,
+                   metadata: metadata,
+                   encrypted_metadata: encrypted_metadata,
+                   account_address: account_address,
+                   idempotency_token: idempotency_token }
+        request(client).send('transaction.create', params).data
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omisego
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Thibault
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-20 00:00:00.000000000 Z
+date: 2018-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday