circle-developer-controlled-wallets 1.1.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

circle/web3/developer_controlled_wallets/models/{estimate_transaction_fee_response.py → estimate_transaction_fee_data.py}

@@ -16,15 +16,15 @@ import json
 
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr
-from circle.web3.developer_controlled_wallets.models.estimated_transaction_fee import EstimatedTransactionFee
+from circle.web3.developer_controlled_wallets.models.transaction_fee import TransactionFee
 
-class EstimateTransactionFeeResponse(BaseModel):
+class EstimateTransactionFeeData(BaseModel):
     """
-    EstimateTransactionFeeResponse
+    EstimateTransactionFeeData
     """
-    high: Optional[EstimatedTransactionFee] = None
-    low: Optional[EstimatedTransactionFee] = None
-    medium: Optional[EstimatedTransactionFee] = None
+    high: Optional[TransactionFee] = None
+    low: Optional[TransactionFee] = None
+    medium: Optional[TransactionFee] = None
     call_gas_limit: Optional[StrictStr] = Field(None, alias="callGasLimit", description="One of ERC-4337 gas fields. The amount of gas to allocate for the main execution call. Only in smart contract account estimation response.")
     verification_gas_limit: Optional[StrictStr] = Field(None, alias="verificationGasLimit", description="One of ERC-4337 gas fields. The amount of gas to allocate for the verification step. Only in smart contract account estimation response.")
     pre_verification_gas: Optional[StrictStr] = Field(None, alias="preVerificationGas", description="One of ERC-4337 gas fields. The amount of gas to pay to compensate the bundler for pre-verification execution and call data. Only in smart contract account estimation response.")
@@ -53,8 +53,8 @@ class EstimateTransactionFeeResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> EstimateTransactionFeeResponse:
-        """Create an instance of EstimateTransactionFeeResponse from a JSON string"""
+    def from_json(cls, json_str: str) -> EstimateTransactionFeeData:
+        """Create an instance of EstimateTransactionFeeData from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -75,13 +75,13 @@ class EstimateTransactionFeeResponse(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> EstimateTransactionFeeResponse:
-        """Create an instance of EstimateTransactionFeeResponse from a dict"""
+    def from_dict(cls, obj: dict) -> EstimateTransactionFeeData:
+        """Create an instance of EstimateTransactionFeeData from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return EstimateTransactionFeeResponse.parse_obj(obj)
+            return EstimateTransactionFeeData.parse_obj(obj)
 
         # fill idempotency_key and ciphertext with placeholder for auto_fill
         if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
@@ -90,10 +90,10 @@ class EstimateTransactionFeeResponse(BaseModel):
         if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
             obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
 
-        _obj = EstimateTransactionFeeResponse.parse_obj({
-            "high": EstimatedTransactionFee.from_dict(obj.get("high")) if obj.get("high") is not None else None,
-            "low": EstimatedTransactionFee.from_dict(obj.get("low")) if obj.get("low") is not None else None,
-            "medium": EstimatedTransactionFee.from_dict(obj.get("medium")) if obj.get("medium") is not None else None,
+        _obj = EstimateTransactionFeeData.parse_obj({
+            "high": TransactionFee.from_dict(obj.get("high")) if obj.get("high") is not None else None,
+            "low": TransactionFee.from_dict(obj.get("low")) if obj.get("low") is not None else None,
+            "medium": TransactionFee.from_dict(obj.get("medium")) if obj.get("medium") is not None else None,
             "call_gas_limit": obj.get("callGasLimit"),
             "verification_gas_limit": obj.get("verificationGasLimit"),
             "pre_verification_gas": obj.get("preVerificationGas")

circle/web3/developer_controlled_wallets/models/estimate_transfer_transaction_fee_request.py

@@ -25,7 +25,7 @@ class EstimateTransferTransactionFeeRequest(BaseModel):
     amounts: conlist(StrictStr, min_items=1) = Field(..., description="Transfer amounts in decimal number format, at least one element is required for transfer. For ERC721 token transfer, the amounts field is required to be [\"1\"] (array with \"1\" as the only element).")
     destination_address: StrictStr = Field(..., alias="destinationAddress", description="The destination blockchain address for the transaction.")
     nft_token_ids: Optional[conlist(StrictStr)] = Field(None, alias="nftTokenIds", description="List of NFT token IDs corresponding with the NFTs to transfer. Batch transfers are supported only for ERC-1155 tokens. The length of NFT token IDs must match the length of amounts.")
-    source_address: Optional[StrictStr] = Field(None, alias="sourceAddress", description="The source blockchain address of the transaction. Required if you don't provide `walletId`. The `sourceAddress` and `walletId` fields are mutually exclusive.")
+    source_address: Optional[StrictStr] = Field(None, alias="sourceAddress", description="The source address of the transaction.")
     token_id: Optional[StrictStr] = Field(None, alias="tokenId", description="System generated identifier of the token. Excluded with `tokenAddress` and `tokenBlockchain`.")
     token_address: Optional[StrictStr] = Field(None, alias="tokenAddress", description="Blockchain address of the transferred token. Empty for native tokens. Excluded with `tokenId`.")
     blockchain: Optional[TokenBlockchain] = None

circle/web3/developer_controlled_wallets/models/fee_level.py

@@ -19,7 +19,7 @@ from aenum import Enum, no_arg
 
 class FeeLevel(str, Enum):
     """
-    A dynamic blockchain fee level setting (`LOW`, `MEDIUM`, or `HIGH`) that will be used to pay gas for the transaction. Calculated based on network traffic, supply of validators, and demand for transaction verification. Cannot be used with `gasLimit`, `gasPrice`, `priorityFee`, or `maxFee`. Estimates for each fee level can be obtained through the `POST /transactions/transfer/estimateFee` API. 
+    A dynamic blockchain fee level setting (`LOW`, `MEDIUM`, or `HIGH`) that will be used to pay gas for the transaction. Calculated based on network traffic, supply of validators, and demand for transaction verification. Cannot be used with `gasPrice`, `priorityFee`, or `maxFee`. Estimates for each fee level can be obtained through the `POST /transactions/transfer/estimateFee` API. 
     """
 
     """

circle/web3/developer_controlled_wallets/models/nft.py

@@ -16,16 +16,16 @@ import json
 from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel, Field, StrictStr
-from circle.web3.developer_controlled_wallets.models.token_response import TokenResponse
+from circle.web3.developer_controlled_wallets.models.token import Token
 
 class Nft(BaseModel):
     """
     Nft
     """
-    amount: StrictStr = Field(..., description="Amount of NFTs on a wallet. For non-fungible token standards, like ERC721, amount will always be “1”; for semi-fungible token standards like ERC1155, amount will correspond to the number of tokens.")
+    amount: StrictStr = Field(..., description="Amount of NFTs on a wallet. For non-fungible token standards, like ERC721, NonFungible, NonFungibleEdition, ProgrammableNonFungible, ProgrammableNonFungibleEdition, amount will always be “1”; for semi-fungible token standards like ERC1155, amount will correspond to the number of tokens; for FungibleAsset, amount can be greater than \"1\".")
     metadata: Optional[StrictStr] = Field(None, description="The metadata of the NFT.")
-    nft_token_id: StrictStr = Field(..., alias="nftTokenId", description="The NFT token ID.")
-    token: TokenResponse = Field(...)
+    nft_token_id: Optional[StrictStr] = Field(None, alias="nftTokenId", description="The NFT token ID.")
+    token: Token = Field(...)
     update_date: datetime = Field(..., alias="updateDate", description="Date and time the resource was last updated, in ISO-8601 UTC format.")
     __properties = ["amount", "metadata", "nftTokenId", "token", "updateDate"]
 
@@ -87,7 +87,7 @@ class Nft(BaseModel):
             "amount": obj.get("amount"),
             "metadata": obj.get("metadata"),
             "nft_token_id": obj.get("nftTokenId"),
-            "token": TokenResponse.from_dict(obj.get("token")) if obj.get("token") is not None else None,
+            "token": Token.from_dict(obj.get("token")) if obj.get("token") is not None else None,
             "update_date": obj.get("updateDate")
         })
         return _obj

circle/web3/developer_controlled_wallets/models/{wallet2.py → nfts.py}

@@ -16,13 +16,13 @@ import json
 
 
 from pydantic import BaseModel, Field
-from circle.web3.developer_controlled_wallets.models.wallet2_data import Wallet2Data
+from circle.web3.developer_controlled_wallets.models.nfts_data import NftsData
 
-class Wallet2(BaseModel):
+class Nfts(BaseModel):
     """
-    Wallet2
+    Nfts
     """
-    data: Wallet2Data = Field(...)
+    data: NftsData = Field(...)
     __properties = ["data"]
 
     def __init__(self, **kwargs):
@@ -48,8 +48,8 @@ class Wallet2(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Wallet2:
-        """Create an instance of Wallet2 from a JSON string"""
+    def from_json(cls, json_str: str) -> Nfts:
+        """Create an instance of Nfts from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -64,13 +64,13 @@ class Wallet2(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> Wallet2:
-        """Create an instance of Wallet2 from a dict"""
+    def from_dict(cls, obj: dict) -> Nfts:
+        """Create an instance of Nfts from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return Wallet2.parse_obj(obj)
+            return Nfts.parse_obj(obj)
 
         # fill idempotency_key and ciphertext with placeholder for auto_fill
         if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
@@ -79,8 +79,8 @@ class Wallet2(BaseModel):
         if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
             obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
 
-        _obj = Wallet2.parse_obj({
-            "data": Wallet2Data.from_dict(obj.get("data")) if obj.get("data") is not None else None
+        _obj = Nfts.parse_obj({
+            "data": NftsData.from_dict(obj.get("data")) if obj.get("data") is not None else None
         })
         return _obj
 

circle/web3/developer_controlled_wallets/models/{get_nfts_response.py → nfts_data.py}

@@ -18,9 +18,9 @@ from typing import List, Optional
 from pydantic import BaseModel, conlist
 from circle.web3.developer_controlled_wallets.models.nft import Nft
 
-class GetNftsResponse(BaseModel):
+class NftsData(BaseModel):
     """
-    GetNftsResponse
+    NftsData
     """
     nfts: Optional[conlist(Nft)] = None
     __properties = ["nfts"]
@@ -48,8 +48,8 @@ class GetNftsResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> GetNftsResponse:
-        """Create an instance of GetNftsResponse from a JSON string"""
+    def from_json(cls, json_str: str) -> NftsData:
+        """Create an instance of NftsData from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -68,13 +68,13 @@ class GetNftsResponse(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> GetNftsResponse:
-        """Create an instance of GetNftsResponse from a dict"""
+    def from_dict(cls, obj: dict) -> NftsData:
+        """Create an instance of NftsData from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return GetNftsResponse.parse_obj(obj)
+            return NftsData.parse_obj(obj)
 
         # fill idempotency_key and ciphertext with placeholder for auto_fill
         if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
@@ -83,7 +83,7 @@ class GetNftsResponse(BaseModel):
         if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
             obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
 
-        _obj = GetNftsResponse.parse_obj({
+        _obj = NftsData.parse_obj({
             "nfts": [Nft.from_dict(_item) for _item in obj.get("nfts")] if obj.get("nfts") is not None else None
         })
         return _obj

circle/web3/developer_controlled_wallets/models/risk_action.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import json
+import pprint
+import re  # noqa: F401
+from aenum import Enum, no_arg
+
+
+
+
+
+class RiskAction(str, Enum):
+    """
+    An action to to take for the decision.
+    """
+
+    """
+    allowed enum values
+    """
+    APPROVE = 'APPROVE'
+    REVIEW = 'REVIEW'
+    FREEZE_WALLET = 'FREEZE_WALLET'
+    DENY = 'DENY'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RiskAction:
+        """Create an instance of RiskAction from a JSON string"""
+        return RiskAction(json.loads(json_str))
+
+

circle/web3/developer_controlled_wallets/models/risk_category.py

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import json
+import pprint
+import re  # noqa: F401
+from aenum import Enum, no_arg
+
+
+
+
+
+class RiskCategory(str, Enum):
+    """
+    The category of the associated risk of the blockchain address.
+    """
+
+    """
+    allowed enum values
+    """
+    SANCTIONS = 'SANCTIONS'
+    CSAM = 'CSAM'
+    ILLICIT_BEHAVIOR = 'ILLICIT_BEHAVIOR'
+    GAMBLING = 'GAMBLING'
+    TERRORIST_FINANCING = 'TERRORIST_FINANCING'
+    UNSUPPORTED = 'UNSUPPORTED'
+    FROZEN = 'FROZEN'
+    OTHER = 'OTHER'
+    HIGH_RISK_INDUSTRY = 'HIGH_RISK_INDUSTRY'
+    PEP = 'PEP'
+    TRUSTED = 'TRUSTED'
+    HACKING = 'HACKING'
+    HUMAN_TRAFFICKING = 'HUMAN_TRAFFICKING'
+    SPECIAL_MEASURES = 'SPECIAL_MEASURES'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RiskCategory:
+        """Create an instance of RiskCategory from a JSON string"""
+        return RiskCategory(json.loads(json_str))
+
+

circle/web3/developer_controlled_wallets/models/risk_score.py

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import json
+import pprint
+import re  # noqa: F401
+from aenum import Enum, no_arg
+
+
+
+
+
+class RiskScore(str, Enum):
+    """
+    Risk score of the signal.
+    """
+
+    """
+    allowed enum values
+    """
+    UNKNOWN = 'UNKNOWN'
+    LOW = 'LOW'
+    MEDIUM = 'MEDIUM'
+    HIGH = 'HIGH'
+    SEVERE = 'SEVERE'
+    BLOCKLIST = 'BLOCKLIST'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RiskScore:
+        """Create an instance of RiskScore from a JSON string"""
+        return RiskScore(json.loads(json_str))
+
+

circle/web3/developer_controlled_wallets/models/risk_signal.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import List
+from pydantic import BaseModel, Field, StrictStr, conlist, validator
+from circle.web3.developer_controlled_wallets.models.risk_category import RiskCategory
+from circle.web3.developer_controlled_wallets.models.risk_score import RiskScore
+from circle.web3.developer_controlled_wallets.models.risk_type import RiskType
+
+class RiskSignal(BaseModel):
+    """
+    Risk signal that includes source, value, and risk type, risk score and risk category.
+    """
+    source: StrictStr = Field(..., description="Source of the risk signal.")
+    source_value: StrictStr = Field(..., alias="sourceValue", description="Value of the source. For example, if source is “ADDRESS”. The source value would be an blockchain address.")
+    risk_score: RiskScore = Field(..., alias="riskScore")
+    risk_categories: conlist(RiskCategory) = Field(..., alias="riskCategories", description="List of risk categories for the signal.")
+    type: RiskType = Field(...)
+    __properties = ["source", "sourceValue", "riskScore", "riskCategories", "type"]
+
+    def __init__(self, **kwargs):
+        if "idempotencyKey" in self.__properties and not kwargs.get("idempotency_key"):
+            kwargs["idempotency_key"] = "#REFILL_PLACEHOLDER"
+
+        if "entitySecretCiphertext" in self.__properties and not kwargs.get("entity_secret_ciphertext"):
+            kwargs["entity_secret_ciphertext"] = "#REFILL_PLACEHOLDER"
+        super().__init__(**kwargs)
+
+
+    @validator('source')
+    def source_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in ('ADDRESS', 'BLOCKCHAIN', 'ASSET'):
+            raise ValueError("must be one of enum values ('ADDRESS', 'BLOCKCHAIN', 'ASSET')")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RiskSignal:
+        """Create an instance of RiskSignal from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RiskSignal:
+        """Create an instance of RiskSignal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RiskSignal.parse_obj(obj)
+
+        # fill idempotency_key and ciphertext with placeholder for auto_fill
+        if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
+            obj["idempotencyKey"] = "#REFILL_PLACEHOLDER"
+
+        if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
+            obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
+
+        _obj = RiskSignal.parse_obj({
+            "source": obj.get("source"),
+            "source_value": obj.get("sourceValue"),
+            "risk_score": obj.get("riskScore"),
+            "risk_categories": obj.get("riskCategories"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

circle/web3/developer_controlled_wallets/models/risk_type.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import json
+import pprint
+import re  # noqa: F401
+from aenum import Enum, no_arg
+
+
+
+
+
+class RiskType(str, Enum):
+    """
+    Type of the signal.
+    """
+
+    """
+    allowed enum values
+    """
+    OWNERSHIP = 'OWNERSHIP'
+    COUNTERPARTY = 'COUNTERPARTY'
+    INDIRECT = 'INDIRECT'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> RiskType:
+        """Create an instance of RiskType from a JSON string"""
+        return RiskType(json.loads(json_str))
+
+

circle/web3/developer_controlled_wallets/models/{sign_message_for_developer_request.py → sign_message_request.py}

@@ -17,11 +17,11 @@ import json
 from typing import Optional, Union
 from pydantic import BaseModel, Field, StrictBool, StrictBytes, StrictStr
 
-class SignMessageForDeveloperRequest(BaseModel):
+class SignMessageRequest(BaseModel):
     """
-    SignMessageForDeveloperRequest
+    SignMessageRequest
     """
-    wallet_id: StrictStr = Field(..., alias="walletId", description="Unique system generated identifier of the wallet. Required when source Address and blockchain is not provided. Mutually exclusive. For contract deploys this wallet ID will be used as the source.")
+    wallet_id: StrictStr = Field(..., alias="walletId", description="System-generated unique identifier of the resource.")
     encoded_by_hex: Optional[StrictBool] = Field(None, alias="encodedByHex", description="Indicator of whether the input message is encoded by hex. If TRUE, then the message should be a hex string. By default, it is False.")
     message: StrictStr = Field(..., description="The user friendly message that needs to be signed. If it is a hex string, encodedByHex needs to be TRUE. The hex string should start with “0x” and have even length.")
     memo: Optional[StrictStr] = Field(None, description="The human readable explanation for this sign action. Useful for presenting with extra information.")
@@ -51,8 +51,8 @@ class SignMessageForDeveloperRequest(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> SignMessageForDeveloperRequest:
-        """Create an instance of SignMessageForDeveloperRequest from a JSON string"""
+    def from_json(cls, json_str: str) -> SignMessageRequest:
+        """Create an instance of SignMessageRequest from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self):
@@ -64,13 +64,13 @@ class SignMessageForDeveloperRequest(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> SignMessageForDeveloperRequest:
-        """Create an instance of SignMessageForDeveloperRequest from a dict"""
+    def from_dict(cls, obj: dict) -> SignMessageRequest:
+        """Create an instance of SignMessageRequest from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return SignMessageForDeveloperRequest.parse_obj(obj)
+            return SignMessageRequest.parse_obj(obj)
 
         # fill idempotency_key and ciphertext with placeholder for auto_fill
         if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
@@ -79,7 +79,7 @@ class SignMessageForDeveloperRequest(BaseModel):
         if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
             obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
 
-        _obj = SignMessageForDeveloperRequest.parse_obj({
+        _obj = SignMessageRequest.parse_obj({
             "wallet_id": obj.get("walletId"),
             "encoded_by_hex": obj.get("encodedByHex"),
             "message": obj.get("message"),

circle/web3/developer_controlled_wallets/models/sign_transaction_request.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    The version of the OpenAPI document: 1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Optional, Union
+from pydantic import BaseModel, Field, StrictBytes, StrictStr
+
+class SignTransactionRequest(BaseModel):
+    """
+    SignTransactionRequest
+    """
+    wallet_id: StrictStr = Field(..., alias="walletId", description="System-generated unique identifier of the resource.")
+    raw_transaction: StrictStr = Field(..., alias="rawTransaction", description="Raw transaction string that needs to be signed. Must be base64 encoded.")
+    memo: Optional[StrictStr] = Field(None, description="The human readable explanation for this sign action. Useful for presenting with extra information.")
+    entity_secret_ciphertext: Union[StrictBytes, StrictStr] = Field(..., alias="entitySecretCiphertext", description="A base64 string expression of the entity secret ciphertext. The entity secret should be encrypted by the entity public key. Circle mandates that the entity secret ciphertext is unique for each API request. ")
+    __properties = ["walletId", "rawTransaction", "memo", "entitySecretCiphertext"]
+
+    def __init__(self, **kwargs):
+        if "idempotencyKey" in self.__properties and not kwargs.get("idempotency_key"):
+            kwargs["idempotency_key"] = "#REFILL_PLACEHOLDER"
+
+        if "entitySecretCiphertext" in self.__properties and not kwargs.get("entity_secret_ciphertext"):
+            kwargs["entity_secret_ciphertext"] = "#REFILL_PLACEHOLDER"
+        super().__init__(**kwargs)
+
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> SignTransactionRequest:
+        """Create an instance of SignTransactionRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> SignTransactionRequest:
+        """Create an instance of SignTransactionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return SignTransactionRequest.parse_obj(obj)
+
+        # fill idempotency_key and ciphertext with placeholder for auto_fill
+        if "idempotencyKey" in cls.__properties and not obj.get("idempotencyKey"):
+            obj["idempotencyKey"] = "#REFILL_PLACEHOLDER"
+
+        if "entitySecretCiphertext" in cls.__properties and not obj.get("entitySecretCiphertext"):
+            obj["entitySecretCiphertext"] = "#REFILL_PLACEHOLDER"
+
+        _obj = SignTransactionRequest.parse_obj({
+            "wallet_id": obj.get("walletId"),
+            "raw_transaction": obj.get("rawTransaction"),
+            "memo": obj.get("memo"),
+            "entity_secret_ciphertext": obj.get("entitySecretCiphertext")
+        })
+        return _obj
+
+