paymentsgate 1.4.9__py3-none-any.whl → 1.5.1__py3-none-any.whl

paymentsgate/models.py

@@ -1,233 +1,289 @@
 from __future__ import annotations
-from dataclasses import dataclass
 import datetime
+from decimal import Decimal
 import json
 from typing import Optional, List
+from pydantic import BaseModel, ConfigDict, Field
+
 
 from paymentsgate.enums import (
-  Currencies, 
-  InvoiceTypes, 
-  Languages, 
-  Statuses, 
-  TTLUnits, 
-  CurrencyTypes, 
-  FeesStrategy,
-  InvoiceDirection,
-  CredentialsTypes
+    Currencies,
+    InvoiceTypes,
+    Languages,
+    Statuses,
+    TTLUnits,
+    CurrencyTypes,
+    FeesStrategy,
+    InvoiceDirection,
+    CredentialsTypes,
 )
 
-from pydantic import BaseModel, ConfigDict
-
-@dataclass
-class Credentials:
-  def __init__(
-      self, 
-      account_id: str,
-      merchant_id: str,
-      project_id: str,
-      private_key: str,
-      public_key: str
-  ):
-     self.account_id = account_id
-     self.merchant_id = merchant_id
-     self.project_id = project_id
-     self.private_key = private_key
-     self.public_key = public_key
-  
-  @classmethod
-  def fromFile(cls, filename):
-    data = json.load(open(filename))
-    return cls(data.get('account_id'),
-               data.get('merchant_id'),
-               data.get('project_id'),
-               data.get('private_key'),
-               data.get('public_key'))
-
-
-@dataclass
-class PayInFingerprintBrowserModel:
-  acceptHeader: str
-  colorDepth: int
-  language: str
-  screenHeight: int
-  screenWidth: int
-  timezone: str
-  userAgent: str
-  javaEnabled: bool
-  windowHeight: int
-  windowWidth: int
-
-@dataclass
-class PayInFingerprintModel:
-  fingerprint: str
-  ip: str
-  country: str
-  city: str
-  state: str
-  zip: str
-  browser: Optional[PayInFingerprintBrowserModel]
-
-@dataclass
-class PayInModel:
-  amount: float
-  currency: Currencies
-  invoiceId: Optional[str] # idempotent key
-  clientId: Optional[str]
-  type: InvoiceTypes
-  bankId: Optional[str]
-  trusted: Optional[bool]
-  successUrl: Optional[str]
-  failUrl: Optional[str]
-  backUrl: Optional[str]
-  clientCard: Optional[str]
-  fingerprint: Optional[PayInFingerprintModel]
-  lang: Optional[Languages]
-   
-@dataclass
-class PayInResponseModel:
-  id: str
-  status: Statuses
-  type: InvoiceTypes
-  url: str
-
-@dataclass
-class PayOutRecipientModel:
-  account_number: str
-  account_owner: Optional[str]
-  account_iban: Optional[str]
-  account_swift: Optional[str]
-  account_phone: Optional[str]
-  account_bic: Optional[str]
-  account_ewallet_name: Optional[str]
-  account_email: Optional[str]
-  account_bank_id: Optional[str]
-  type: Optional[CredentialsTypes]
-
-@dataclass
-class PayOutModel:
-  currency: Optional[Currencies] # currency from, by default = usdt
-  currencyTo:Currencies
-  amount: float
-  invoiceId: Optional[str] # idempotent key
-  clientId: Optional[str]
-  ttl: Optional[int]
-  ttl_unit: Optional[TTLUnits]
-  finalAmount: Optional[float]
-  sender_name: Optional[str]
-  baseCurrency: Optional[CurrencyTypes]
-  feesStrategy: Optional[FeesStrategy]
-  recipient: PayOutRecipientModel
-  quoteId: Optional[str]
-   
-@dataclass
-class PayOutResponseModel:
-  id: str
-  status: Statuses
-
-@dataclass
-class GetQuoteModel:
-  currency_from: Currencies
-  currency_to: Currencies
-  amount: float
-  subtype: InvoiceTypes
-
-@dataclass
-class QuoteEntity:
-  currency_from: CurrencyModel
-  currency_to: CurrencyModel
-  pair: str
-  rate: float
-
-@dataclass
-class GetQuoteResponseModel:
-  id: Optional[str]  = None
-  finalAmount: Optional[float]  = None
-  direction: Optional[InvoiceDirection]  = None
-  fullRate: Optional[float]  = None
-  fullRateReverse: Optional[float]  = None
-  fees: Optional[float]  = None
-  fees_percent: Optional[float]  = None
-  quotes: Optional[List[QuoteEntity]]  = None
-  expiredAt: Optional[datetime.datetime] = None
-
-  #deprecated
-  currency_from: Optional[CurrencyModel] = None
-  currency_to: Optional[CurrencyModel] = None
-  currency_middle: Optional[CurrencyModel] = None
-  rate1: Optional[float] = None
-  rate2: Optional[float] = None
-  rate3: Optional[float] = None
-  net_amount: Optional[float] = None
-  metadata: Optional[object] = None
-
-@dataclass
-class DepositAddressResponseModel:
-  currency: Currencies
-  address: str
-  expiredAt: datetime
-
-@dataclass
-class CurrencyModel:
-  _id: str
-  type: CurrencyTypes
-  code: Currencies
-  symbol: str
-  label: Optional[str]
-  decimal: int
-  countryCode: Optional[str]
-  countryName: Optional[str]
-
-@dataclass
-class BankModel:
-  name: str
-  title: str
-  currency: Currencies
-  fpsId: str
-
-@dataclass
-class InvoiceStatusModel:
-  name: Statuses
-  createdAt: datetime
-  updatedAt: datetime
-
-@dataclass
-class InvoiceAmountModel:
-  crypto: float
-  fiat: float
-  fiat_net: float
-
-@dataclass
-class InvoiceMetadataModel:
-  invoiceId: Optional[str]
-  clientId: Optional[str]
-  fiatAmount: Optional[float]
-
-@dataclass
-class InvoiceModel:
-  _id: str
-  orderId: str
-  projectId: str
-  currencyFrom: CurrencyModel
-  currencyTo: CurrencyModel
-  direction: InvoiceDirection
-  amount: float
-  status: InvoiceStatusModel
-  amounts: InvoiceAmountModel
-  metadata: InvoiceMetadataModel
-  receiptUrls: List[str]
-  isExpired: bool
-  createdAt: datetime
-  updatedAt: datetime
-  expiredAt: datetime
-
-@dataclass
-class AssetsAccountModel:
-  currency: CurrencyModel;
-  total: float
-  pending: float
-  available: float
-
-@dataclass
-class AssetsResponseModel:
-  assets: List[AssetsAccountModel]
 
+class BaseRequestModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class BaseResponseModel(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+
+class Credentials(BaseModel):
+    account_id: str
+    public_key: str
+    private_key: Optional[str] = Field(default=None)
+    merchant_id: Optional[str] = Field(default=None)
+    project_id: Optional[str] = Field(default=None)
+
+    @classmethod
+    def fromFile(cls, filename):
+        data = json.load(open(filename))
+        return cls(**data)
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class PayInFingerprintBrowserModel(BaseRequestModel):
+    acceptHeader: str
+    colorDepth: int
+    language: str
+    screenHeight: int
+    screenWidth: int
+    timezone: str
+    userAgent: str
+    javaEnabled: bool
+    windowHeight: int
+    windowWidth: int
+
+
+class PayInFingerprintModel(BaseRequestModel):
+    fingerprint: str
+    ip: str
+    country: str
+    city: str
+    state: str
+    zip: str
+    browser: Optional[PayInFingerprintBrowserModel]
+
+
+class PayInModel(BaseRequestModel):
+    amount: float  # decimals: 2
+    currency: Currencies
+    country: Optional[str]  # Country iso code
+    invoiceId: Optional[str]  # idempotent key
+    clientId: Optional[str]  # uniq client ref
+    type: InvoiceTypes  # Invoice subtype, see documentation
+    bankId: Optional[str]  # ID from bank list or NSPK id
+    trusted: Optional[bool]
+    successUrl: Optional[str]
+    failUrl: Optional[str]
+    backUrl: Optional[str]
+    clientCard: Optional[str]
+    clientName: Optional[str]
+    fingerprint: Optional[PayInFingerprintModel]
+    lang: Optional[Languages]
+    sync: Optional[bool]  # sync h2h scheme, see documentation
+    multiWidgetOptions: Optional[PayInMultiWidgetOptions]
+    theme: Optional[str]  # personalized widget theme
+
+
+class PayInResponseModel(BaseResponseModel):
+    id: str
+    status: Statuses
+    type: InvoiceTypes
+    url: Optional[str]
+    deeplink: Optional[str]
+    m10: Optional[str]
+    cardholder: Optional[str]
+    account: Optional[str]
+    bankId: Optional[str]
+    accountSubType: Optional[str]
+
+
+class PayOutRecipientModel(BaseRequestModel):
+    account_number: str | None = None  #  IBAN, Phone, Card, local bank account number, wallet number, etc'
+    account_owner: str | None = None  # FirstName LastName or FirstName MiddleName LastName
+    account_iban: str | None = None  # use only cases where iban is't primary  account id
+    account_swift: str | None = None  # for swift transfers only
+    account_phone: str | None = None  # additional recipient phone number, use only cases where phone is't primary  account id
+    account_bic: str | None = None  # recipient bank id
+    account_ewallet_name: str | None = None  # additional recipient wallet provider info
+    account_email: str | None = None  # additional recipient email, use only cases where email is't primary account id
+    account_bank_id: str | None = None  # recipient bankId (from API banks or RU NSPK id)
+    account_internal_client_number: str | None = None  # Bank internal identifier used for method banktransferphp (Philippines)
+    type: CredentialsTypes | None = None  # primary credential type
+
+
+class PayOutModel(BaseRequestModel):
+    currency: Currencies | None = None  # currency from, by default = usdt
+    currencyTo: Currencies | None = None  # currency to, fiat only, if use quoteId - not required
+    amount: Decimal | None = None  # decimals: 2, if use quoteId - not required
+    invoiceId: str | None = None  # idempotent key
+    clientId: str | None = None  # uniq client ref
+    ttl: int | None = None
+    ttl_unit: TTLUnits | None = None
+    finalAmount: Decimal | None = None  # Optional, for pre-charge rate lock
+    sender_name: str | None = None  # sender personal short data
+    sender_personal: PayOutSenderModel | None = None
+    baseCurrency: CurrencyTypes | None = None
+    feesStrategy: FeesStrategy | None = None
+    recipient: PayOutRecipientModel
+    quoteId: str | None = None
+    src_amount: str | None = None  # Optional, source amount in local currency for 2phase payout
+    type: InvoiceTypes | None = None  # payout transaction scheme hint
+
+
+class PayOutResponseModel(BaseResponseModel):
+    id: str
+    status: str
+
+
+class GetQuoteModel(BaseRequestModel):
+    currency_from: Currencies
+    currency_to: Currencies
+    amount: Decimal
+    subtype: InvoiceTypes | None = None
+    currency_original: Currencies | None = None
+
+
+class QuoteEntity(BaseResponseModel):
+    currencyFrom: Currencies
+    currencyTo: Currencies
+    pair: str
+    rate: float
+
+
+class GetQuoteResponseModel(BaseResponseModel):
+    id: str
+    finalAmount: Decimal
+    direction: InvoiceDirection
+    fullRate: Decimal
+    fullRateReverse: Decimal
+    fees: Decimal
+    fees_percent: Decimal
+    quotes: List[QuoteEntity]
+    expiredAt: Optional[datetime.datetime] | None = None
+
+    # deprecated
+    currency_from: Optional[CurrencyModel] = Field(default=None)
+    currency_to: Optional[CurrencyModel] = Field(default=None)
+    currency_middle: Optional[CurrencyModel] = Field(default=None)
+    rate1: Optional[float] = Field(default=None)
+    rate2: Optional[float] = Field(default=None)
+    rate3: Optional[float] = Field(default=None)
+    net_amount: Optional[float] = Field(default=None)
+    metadata: Optional[object] = Field(default=None)
+
+
+class DepositAddressResponseModel(BaseResponseModel):
+    currency: Currencies
+    address: str
+    expiredAt: datetime.datetime
+
+
+class CurrencyModel(BaseResponseModel):
+    _id: str
+    type: CurrencyTypes
+    code: Currencies
+    symbol: str
+    label: Optional[str] = Field(default=None)
+    decimal: int
+    countryCode: Optional[str] = Field(default=None)
+    countryName: Optional[str] = Field(default=None)
+
+
+class BankModel(BaseResponseModel):
+    name: str
+    title: str
+    currency: Currencies
+    fpsId: str
+
+
+class InvoiceStatusModel(BaseResponseModel):
+    name: Statuses
+    createdAt: datetime.datetime
+    updatedAt: datetime.datetime
+
+
+class InvoiceAmountModel(BaseResponseModel):
+    crypto: float
+    fiat: float
+    fiat_net: float
+
+
+class InvoiceMetadataModel(BaseResponseModel):
+    invoiceId: Optional[str]
+    clientId: Optional[str]
+    fiatAmount: Optional[float]
+
+
+class InvoiceModel(BaseResponseModel):
+    id: str | None = Field(..., alias='_id')
+    orderId: str
+    projectId: str
+    currencyFrom: CurrencyModel
+    currencyTo: CurrencyModel
+    direction: InvoiceDirection
+    amount: float
+    status: InvoiceStatusModel
+    amounts: InvoiceAmountModel
+    metadata: InvoiceMetadataModel
+    receiptUrls: List[str]
+    isExpired: bool
+    createdAt: datetime.datetime | None = None
+    updatedAt: datetime.datetime | None = None
+    expiredAt: datetime.datetime | None = None
+
+
+class AssetsAccountModel(BaseResponseModel):
+    currency: CurrencyModel
+    total: float
+    pending: float
+    available: float
+
+
+class AssetsResponseModel(BaseResponseModel):
+    assets: List[AssetsAccountModel]
+
+
+class PayInMultiWidgetOptions(BaseRequestModel):
+    offerAmount: Optional[bool]  # show amount select from best offers
+    elqrBanks: Optional[str]  # elqr bank list
+
+
+class PayOutSenderModel(BaseRequestModel):
+    name: Optional[str]
+    birthday: Optional[str]
+    phone: Optional[str]
+    passport: Optional[str]
+
+
+class PayOutTlvRequestModel(BaseRequestModel):
+    quoteId: str  # ID from /fx/tlv response
+    invoiceId: Optional[str]
+    clientId: Optional[str]
+    sender_personal: Optional[PayOutSenderModel]
+
+
+class GetQuoteTlv(BaseRequestModel):
+    data: str
+
+
+class QuoteTlvResponse(BaseResponseModel):
+    id: str
+    amount: float  # fiat local amount
+    amountCrypto: float  # total crypto amount inc. fees
+    currencyCode: Currencies  # local currency
+    feeInCrypto: float  # total fee in crypto
+    feePercent: float  # fee percent
+    qrVersion: int  # qr code version, 1 - nspk, 2 - tlv encoded, 3 - tlv plain
+    rate: float  # exchange rate
+    merchant: Optional[str] = Field(default=None)  # merchant title
+    logo: Optional[str] = Field(default=None)  # merchant logo
+
+
+class PayOutTlvRequest(BaseRequestModel):
+    quoteId: str  # quote.id ref
+    invoiceId: Optional[str] = Field(default=None)
+    clientId: Optional[str] = Field(default=None)
+    src_amount: Optional[float] = Field(default=None)
+    sender_personal: Optional[PayOutSenderModel] = Field(default=None)

paymentsgate/signature.py

@@ -0,0 +1,91 @@
+import enum
+import base64
+import hashlib
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives import hashes, serialization
+
+
+class SignatureCheckMode(enum.StrEnum):
+    none = enum.auto()
+    decrypt_only = enum.auto()
+    full = enum.auto()
+
+
+def flatten_stringify(d: dict, count: int = 1) -> dict:
+    def inner(d, count):
+        res = {}
+        for k, v in d.items():
+            if type(v) is list:
+                count += 1
+            elif type(v) is dict:
+                new_d, count = inner(v, count)
+                res = res | new_d
+            else:
+                res[(k.lower(), count)] = str(v).lower() if type(v) is bool else str(v)
+                count += 1
+        return res, count
+
+    (d, _) = inner(d, count)
+    return d
+
+
+class SignatureHelper:
+    def __init__(
+        self,
+        private_key_data: str,
+        password: str = None,
+        mode: SignatureCheckMode = SignatureCheckMode.full,
+    ) -> None:
+        decoded_key = base64.decodebytes(private_key_data.encode("utf-8"))
+        self.private_key = serialization.load_pem_private_key(
+            decoded_key, password=password
+        )
+        self.mode = mode
+
+    def check(self, api_signature: str, json_value: dict) -> bool:
+        try:
+            self._check_impl(api_signature, json_value)
+        except ValueError:
+            return False
+        except:
+            raise
+        return True
+
+    def sign(self, json_value: dict) -> str:
+        digest = self.encode(json_value)
+        return base64.encodebytes(
+            self.private_key.sign(
+                digest,
+                padding.PSS(
+                    mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH,
+                ),
+                hashes.SHA256(),
+            )
+        ).decode("utf-8")
+
+    def encode(self, json_value: dict) -> bytes:
+        d = flatten_stringify(json_value)
+        val = "".join(d[k] for k in sorted(d.keys()))
+        return hashlib.sha256(val.encode("utf-8")).hexdigest().encode("utf-8")
+
+    def check_raise(self, api_signatre: str, json_value: dict) -> None:
+        self._check_impl(api_signatre, json_value)
+
+    def _check_impl(self, api_signature: str, json_value: dict) -> None:
+        if self.mode == SignatureCheckMode.none:
+            return
+        if len(api_signature) < 256:
+            raise ValueError(
+                "wrong api_signature length, check Webhook version.in project settings, should be 3!"
+            )
+        decoded_signature = base64.decodebytes(api_signature.encode("utf-8"))
+        alg = hashes.SHA256()
+        digest = self.private_key.decrypt(
+            decoded_signature,
+            padding.OAEP(mgf=padding.MGF1(algorithm=alg), algorithm=alg, label=None),
+        )
+        if self.mode == SignatureCheckMode.decrypt_only:
+            return
+        if self.encode(json_value) != digest:
+            raise ValueError("Error while checking signature")

paymentsgate/tokens.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from jwt import JWT
 import time
 
+
 @dataclass
 class AccessToken:
     token: str
@@ -11,16 +12,18 @@ class AccessToken:
         self.token = token
         jwdInstance = JWT()
         parsed = jwdInstance.decode(token, do_verify=False, do_time_check=False)
-        self.expiredAt = int(parsed['exp'])
+        self.expiredAt = int(parsed["exp"])
+
     @property
     def is_expired(self):
         if self.expiredAt:
-            return int(time.time()) >= self.expiredAt;
+            return int(time.time()) >= self.expiredAt
         return True
 
     def __str__(self) -> str:
         return self.token
 
+
 @dataclass
 class RefreshToken:
     token: str
@@ -29,12 +32,12 @@ class RefreshToken:
     def __init__(self, token, expiredAt):
         self.token = token
         self.expiredAt = expiredAt
+
     @property
     def is_expired(self):
         if self.expiredAt:
-            return int(time.time()) >= self.expiredAt;
+            return int(time.time()) >= self.expiredAt
         return True
 
     def __str__(self) -> str:
         return self.token
-    

paymentsgate/transport.py

@@ -1,22 +1,20 @@
-from dataclasses import dataclass
 from pydantic import BaseModel
 
-@dataclass
-class Request:
+
+class Request(BaseModel):
     method: str
     path: str
-    content_type: str = 'application/json'
+    content_type: str = "application/json"
     headers: dict[str, str] | None = None
     body: dict | None = None
     noAuth: bool | None = False
     signature: bool | None = False
 
 
-@dataclass
-class Response:
+class Response(BaseModel):
     raw_body: bytes
-    json: dict
     status_code: int
+    json_body: dict | None = None
 
     @property
     def success(self) -> bool:
@@ -24,8 +22,13 @@ class Response:
 
     def cast(self, model: BaseModel, error: dict):
         if self.success:
-            return model(**self.json)
-        return error(self.json.get('error'), self.json.get('message'), self.json.get('data'), self.json.get('status'));
-    
+            return model(**self.json_body)
+        return error(
+            self.json_body.get("error"),
+            self.json_body.get("message"),
+            self.json_body.get("data"),
+            self.json_body.get("status"),
+        )
+
     def __str__(self) -> str:
-       return self.raw_body.decode("utf-8")
+        return self.raw_body.decode("utf-8")

paymentsgate/types.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    refresh_token: str
+    expires_in: int