sidan-gin 0.1.7__py3-none-any.whl

sidan_gin/types/__init__.py

@@ -0,0 +1,11 @@
+# flake8: noqa
+
+from .account_info import *
+from .asset import *
+from .asset_metadata import *
+from .block_info import *
+from .network import *
+from .protocol import *
+from .transaction_info import *
+from .utxo import *
+from .value import *

sidan_gin/types/account_info.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AccountInfo:
+    active: bool
+    pool_id: Optional[str]
+    balance: str
+    rewards: str
+    withdrawals: str

sidan_gin/types/asset.py

@@ -0,0 +1,68 @@
+# flake8: noqa: E501
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Asset:
+    unit: str
+    quantity: str
+
+    def __repr__(self):
+        return f"Asset(unit={self.unit}, quantity={self.quantity})"
+
+
+@dataclass
+class Assets:
+    def __init__(self, assets: Optional[List[Asset]] = None):
+        self.assets = assets if assets is not None else []
+
+    def get_lovelace(self) -> int:
+        """
+        Get the 'lovelace' quantity if it exists, otherwise return 0.
+        """
+        for asset in self.assets:
+            if asset.unit == "lovelace":
+                try:
+                    return int(asset.quantity)
+                except ValueError:
+                    return 0
+        return 0
+
+    def pop_asset_by_unit(self, unit: str) -> Optional[Asset]:
+        """
+        Pop the first asset with the specified unit and return it.
+        """
+        for i, asset in enumerate(self.assets):
+            if asset.unit == unit:
+                pop_asset = self.assets.pop(i)
+                return pop_asset
+        return None
+
+    def merge_assets(self, assets: List[Asset]) -> List[Asset]:
+        """
+        Merge new assets into the current assets list. If units match, quantities are added.
+        """
+        merged_assets = {}
+        for asset in self.assets + assets:
+            if asset.unit in merged_assets:
+                merged_assets[asset.unit].quantity = self.add_quantities(
+                    merged_assets[asset.unit].quantity, asset.quantity
+                )
+            else:
+                merged_assets[asset.unit] = asset
+        return list(merged_assets.values())
+
+    @staticmethod
+    def add_quantities(quantity1: str, quantity2: str) -> str:
+        """
+        Add two quantities (represented as strings) and return the result as a string.
+        """
+        try:
+            int_quantity1 = int(quantity1)
+            int_quantity2 = int(quantity2)
+            sum_quantity = int_quantity1 + int_quantity2
+            return str(sum_quantity)
+        except ValueError:
+            return "0"

sidan_gin/types/asset_metadata.py

@@ -0,0 +1,3 @@
+from typing import Any, Dict
+
+AssetMetadata = Dict[str, Any]

sidan_gin/types/block_info.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class BlockInfo:
+    time: int
+    hash: str
+    slot: str
+    epoch: int
+    epoch_slot: str
+    slot_leader: str
+    size: int
+    tx_count: int
+    output: str
+    fees: str
+    previous_block: str
+    next_block: str
+    confirmations: int
+    operational_certificate: str
+    vrf_key: str

sidan_gin/types/network.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Network:
+    """Equivalent of Go's Network type with constants."""
+
+    TESTNET = "testnet"
+    PREVIEW = "preview"
+    PREPROD = "preprod"
+    MAINNET = "mainnet"
+
+    ALL_NETWORKS = [TESTNET, PREVIEW, PREPROD, MAINNET]
+
+    @staticmethod
+    def is_network(value: str) -> bool:
+        return value in Network.ALL_NETWORKS

sidan_gin/types/protocol.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Protocol:
+    epoch: int
+    min_fee_a: int
+    min_fee_b: int
+    max_block_size: int
+    max_tx_size: int
+    max_block_header_size: int
+    key_deposit: int
+    pool_deposit: int
+    decentralisation: float
+    min_pool_cost: str
+    price_mem: float
+    price_step: float
+    max_tx_ex_mem: str
+    max_tx_ex_steps: str
+    max_block_ex_mem: str
+    max_block_ex_steps: str
+    max_val_size: int
+    collateral_percent: int
+    max_collateral_inputs: int
+    coins_per_utxo_size: int
+    min_fee_ref_script_cost_per_byte: int

sidan_gin/types/transaction_info.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class TransactionInfo:
+    index: int
+    block: str
+    hash: str
+    slot: str
+    fees: str
+    size: int
+    deposit: str
+    invalid_before: str
+    invalid_after: str

sidan_gin/types/utxo.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from sidan_gin.types.asset import Asset
+
+
+@dataclass
+class Input:
+    output_index: int
+    tx_hash: str
+
+
+@dataclass
+class Output:
+    address: str
+    amount: List[Asset]
+    data_hash: Optional[str] = None
+    plutus_data: Optional[str] = None
+    script_ref: Optional[str] = None
+    script_hash: Optional[str] = None
+
+
+@dataclass
+class UTxO:
+    input: Input
+    output: Output

sidan_gin/types/value.py

@@ -0,0 +1,96 @@
+# flake8: noqa: E501
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass
+class Asset:
+    unit: str
+    quantity: str  # Stored as a string for compatibility with Cardano data
+
+
+class Value:
+    def __init__(self):
+        # Represents the value map where the key is the asset name and the value is the quantity
+        self.value: Dict[str, int] = {}
+
+    @staticmethod
+    def from_assets(assets: Optional[List[Asset]]) -> "Value":
+        """Create a new Value instance with the given assets."""
+        value = Value()
+        if assets is None:
+            return value
+        return value.add_assets(assets)
+
+    def add_asset(self, asset: Asset) -> "Value":
+        """Add an asset to the Value class's value record."""
+        quantity = int(asset.quantity)
+        if asset.unit in self.value:
+            self.value[asset.unit] += quantity
+        else:
+            self.value[asset.unit] = quantity
+        return self
+
+    def add_assets(self, assets: List[Asset]) -> "Value":
+        """Add multiple assets to the Value class's value record."""
+        for asset in assets:
+            self.add_asset(asset)
+        return self
+
+    def negate_asset(self, asset: Asset) -> "Value":
+        """Deduct the value amount of an asset from the Value class's value record."""
+        if asset is None:
+            return self
+        quantity = int(asset.quantity)
+        if asset.unit in self.value:
+            new_quantity = self.value[asset.unit] - quantity
+            if new_quantity <= 0:
+                del self.value[asset.unit]
+            else:
+                self.value[asset.unit] = new_quantity
+        return self
+
+    def negate_assets(self, assets: List[Asset]) -> "Value":
+        """Deduct the value amount of multiple assets from the Value class's value record."""
+        for asset in assets:
+            self.negate_asset(asset)
+        return self
+
+    def merge(self, *values: "Value") -> "Value":
+        """Merge multiple Value class's value record into the current Value class's value record."""
+        for other in values:
+            if other is None:
+                continue
+            for unit, quantity in other.value.items():
+                if unit in self.value:
+                    self.value[unit] += quantity
+                else:
+                    self.value[unit] = quantity
+        return self
+
+    def get(self, unit: str) -> int:
+        """Get the quantity of an asset in the Value class's value record."""
+        return self.value.get(unit, 0)
+
+    def units(self) -> List[str]:
+        """Get the list of asset names in the Value class's value record."""
+        return list(self.value.keys())
+
+    def is_empty(self) -> bool:
+        """Check if the Value class's value record is empty."""
+        return len(self.value) == 0
+
+    def to_assets(self) -> List[Asset]:
+        """Convert the Value class's value record into a list of Asset."""
+        return [
+            Asset(unit=unit, quantity=str(quantity))
+            for unit, quantity in self.value.items()
+        ]
+
+    def geq(self, other: "Value") -> bool:
+        """Check if the value is greater than or equal to another value."""
+        for unit, quantity in other.value.items():
+            if self.value.get(unit, 0) < quantity:
+                return False
+        return True

sidan_gin/wallet/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+
+from .wallet import Wallet

sidan_gin/wallet/cli.py

@@ -0,0 +1,13 @@
+import CardanoSigner
+
+
+class CliWallet:
+    def __init__(self, cli_skey: str):
+        self.cli_skey = cli_skey
+
+    def sign_tx(self, tx_hex: str) -> str:
+        # Implement CLI-based signing
+        return CardanoSigner.sign_cli(
+            self.cli_skey,
+            tx_hex,
+        )

sidan_gin/wallet/derivation_indices.py

@@ -0,0 +1,30 @@
+class DerivationIndices:
+    @classmethod
+    def default(cls):
+        """Default derivation indices (payment with index 0)"""
+        return DerivationIndices.payment(0, 0)
+
+    @classmethod
+    def payment(cls, account_index: int, key_index: int):
+        """Creates derivation indices for payment accounts"""
+        return DerivationIndices.raw_path(
+            ["1852'", "1815'", f"{str(account_index)}'", str(0), str(key_index)]
+        )
+
+    @classmethod
+    def stake(cls, account_index: int, key_index: int):
+        """Creates derivation indices for stake accounts"""
+        return DerivationIndices.raw_path(
+            ["1852'", "1815'", f"{str(account_index)}'", str(2), str(key_index)]
+        )
+
+    @classmethod
+    def drep(cls, account_index: int, key_index: int):
+        """Creates derivation indices for drep accounts"""
+        return DerivationIndices.raw_path(
+            ["1852'", "1815'", f"{str(account_index)}'", str(3), str(key_index)]
+        )
+
+    def raw_path(derivation_indices: list[str]):
+        """Creates a raw path from derivation indices"""
+        return f"m/{'/'.join(derivation_indices)}"

sidan_gin/wallet/mnemonic.py

@@ -0,0 +1,25 @@
+import CardanoSigner
+
+from sidan_gin.wallet.derivation_indices import DerivationIndices
+
+
+class MnemonicWallet:
+    def __init__(self, mnemonic_phrase: str):
+        self.mnemonic_phrase = mnemonic_phrase
+        self.derivation_indices = DerivationIndices.default()
+
+    def payment_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.payment(account_index, key_index)
+
+    def stake_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.stake(account_index, key_index)
+
+    def drep_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.drep(account_index, key_index)
+
+    def sign_tx(self, tx_hex: str) -> str:
+        return CardanoSigner.sign_mnemonic(
+            self.mnemonic_phrase,
+            self.derivation_indices,
+            tx_hex,
+        )

sidan_gin/wallet/root_key.py

@@ -0,0 +1,25 @@
+import CardanoSigner
+
+from sidan_gin.wallet.derivation_indices import DerivationIndices
+
+
+class RootKeyWallet:
+    def __init__(self, root_key: str):
+        self.root_key = root_key
+        self.derivation_indices = DerivationIndices.default()
+
+    def payment_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.payment(account_index, key_index)
+
+    def stake_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.stake(account_index, key_index)
+
+    def drep_account(self, account_index: int, key_index: int):
+        self.derivation_indices = DerivationIndices.drep(account_index, key_index)
+
+    def sign_tx(self, tx_hex: str) -> str:
+        return CardanoSigner.sign_bech32(
+            self.root_key,
+            self.derivation_indices,
+            tx_hex,
+        )

sidan_gin/wallet/wallet.py

@@ -0,0 +1,48 @@
+from typing import Union
+
+from sidan_gin.wallet.cli import CliWallet
+from sidan_gin.wallet.mnemonic import MnemonicWallet
+from sidan_gin.wallet.root_key import RootKeyWallet
+
+
+# Main Wallet class that users will interact with
+class Wallet:
+    def __init__(self, wallet_type: Union[MnemonicWallet, RootKeyWallet, CliWallet]):
+        self.wallet_type = wallet_type
+
+    @classmethod
+    def new_mnemonic(cls, mnemonic_phrase: str) -> "Wallet":
+        """Create a new wallet from a mnemonic phrase"""
+        return cls(MnemonicWallet(mnemonic_phrase))
+
+    @classmethod
+    def new_root_key(cls, root_key: str) -> "Wallet":
+        """Create a new wallet from a root key"""
+        return cls(RootKeyWallet(root_key))
+
+    @classmethod
+    def new_cli(cls, cli_skey: str) -> "Wallet":
+        """Create a new wallet that uses CLI signing"""
+        return cls(CliWallet(cli_skey))
+
+    def payment_account(self, account_index: int, key_index: int) -> "Wallet":
+        """Configure for payment account operations"""
+        if isinstance(self.wallet_type, (MnemonicWallet, RootKeyWallet)):
+            self.wallet_type.payment_account(account_index, key_index)
+        return self
+
+    def stake_account(self, account_index: int, key_index: int) -> "Wallet":
+        """Configure for stake account operations"""
+        if isinstance(self.wallet_type, (MnemonicWallet, RootKeyWallet)):
+            self.wallet_type.stake_account(account_index, key_index)
+        return self
+
+    def drep_account(self, account_index: int, key_index: int) -> "Wallet":
+        """Configure for drep account operations"""
+        if isinstance(self.wallet_type, (MnemonicWallet, RootKeyWallet)):
+            self.wallet_type.drep_account(account_index, key_index)
+        return self
+
+    def sign_tx(self, tx_hex: str) -> str:
+        """Sign a transaction using the configured wallet"""
+        return self.wallet_type.sign_tx(tx_hex)

sidan_gin-0.1.7.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: sidan-gin
+Version: 0.1.7
+Summary: A python library for Cardano development, compatible with Mesh and Whisky types.
+License: Apache-2.0
+License-File: LICENSE
+Keywords: cardano
+Author: HinsonSIDAN
+Author-email: wongkahinhinson@gmail.com
+Requires-Python: >3.11,<4.0.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: cardano-python-signing-module (>=0.1.0,<0.2.0)
+Requires-Dist: cryptography (>=44.0.2,<45.0.0)
+Requires-Dist: pycardano (>=0.12.3,<0.13.0)
+Requires-Dist: requests (>=2.25,<3.0)
+Project-URL: Documentation, https://github.com/sidan-lab/gin
+Project-URL: Homepage, https://github.com/sidan-lab/gin
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <hr />
+    <h2 align="center" style="border-bottom: none"><img style="position: relative; top: 0.25rem;" src="https://raw.githubusercontent.com/sidan-lab/brand_assets/main/sidan_s_square.png" alt="Whisky" height="30" /> Gin - Cardano Python SDK</h2>
+
+[![Licence](https://img.shields.io/github/license/sidan-lab/gin)](https://github.com/sidan-lab/gin/blob/master/LICENSE)
+[![Test](https://github.com/sidan-lab/gin/actions/workflows/build.yml/badge.svg)](https://github.com/sidan-lab/gin/actions/workflows/build.yml)
+[![Publish](https://github.com/sidan-lab/bin/actions/workflows/publish.yml/badge.svg)](https://github.com/sidan-lab/bin/actions/workflows/publish.yml)
+
+[![PyPi version](https://badgen.net/pypi/v/sidan_gin)](https://pypi.python.org/pypi/sidan_gin/)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/sidan_gin)](https://pypi.python.org/pypi/sidan_gin/)
+[![PyPI download month](https://img.shields.io/pypi/dm/sidan_gin)](https://pypi.python.org/pypi/sidan_gin/)
+
+[![Twitter/X](https://img.shields.io/badge/Follow%20us-@sidan__lab-blue?logo=x&style=for-the-badge)](https://x.com/sidan_lab)
+
+  <hr/>
+</div>
+
+# gin
+
+Gin is a Python library for Cardano development, compatible with Mesh and Whisky types. It also re-export core logics implemented in Whisky to support stable serialization in Python. Supported features:
+
+- Identical type system with Mesh and Whisky.
+- Transaction signing
+- Cipher data encryption and decryption
+
+## Installation
+
+```sh
+pip install sidan_gin
+```
+
+## Getting Started
+
+## Documentation
+
+- Coming soon
+
+![Alt](https://repobeats.axiom.co/api/embed/0446bd7a0e9d2cd208432845cda9182f263321cd.svg "Repobeats analytics image")
+

sidan_gin-0.1.7.dist-info/RECORD

@@ -0,0 +1,38 @@
+sidan_gin/__init__.py,sha256=vu8JEo4ADPBvK7l6_QhnhlKEnSYEmphSc7NE3jZG1dY,85
+sidan_gin/encryption/__init__.py,sha256=4eCzQX7vgrrnnQFWVt86Kc_bBq9mzCdAuJbnNNaA62Y,38
+sidan_gin/encryption/cipher.py,sha256=4xNKoyfUwkftLYxFajRHPOVaBYnXF4_alG2LeXvGbeg,5249
+sidan_gin/python_signing_module/.git,sha256=6zrYBIbA30J88rlvjaRZWlwV1EC2lzsydBHgsqEoMrA,66
+sidan_gin/python_signing_module/.gitignore,sha256=NP7DXi3vJqhsgANgH1Vw5JfOxBhy0G5VVr2jRGDe_-s,102
+sidan_gin/python_signing_module/.vscode/settings.json,sha256=k2FuGx7eGPpQrMGxXB6XwIH3IAzJcDnpRlWCRHrVkr8,771
+sidan_gin/python_signing_module/Cargo.toml,sha256=OgBinJNCwkvOJqT4kRIB3hSGGWDwpbbJTUzI4jqD3Eo,180
+sidan_gin/python_signing_module/README.md,sha256=dQcu4nM06TwTJjKTgtbTp1XuuL-hI5Q02mbZZtmKVTI,107
+sidan_gin/python_signing_module/__init__.py,sha256=mIzz621tHzLvVcEii5Rf3X780vThQo_cWGasKTJOnoo,30
+sidan_gin/python_signing_module/build.rs,sha256=ot5FYadCsc7GA2welu6Z4rECHKKtu-R061-hrlonWJE,238
+sidan_gin/python_signing_module/build.sh,sha256=YVw3e0Jp9GQCxMIyFU2SzWQKhRdoiQGT-5ZmBTEpxBs,206
+sidan_gin/python_signing_module/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sidan_gin/python_signing_module/src/lib.rs,sha256=k9IL2WeA3SGhWKOku87LK0bsts1JLTzwn7sA6q1Qdpw,3256
+sidan_gin/python_signing_module/src/setup.py,sha256=Y0x1l7VhBIWbqnLLCL9N_boB4afUyG1k66VQwiBZsqo,517
+sidan_gin/python_signing_module/src/signer.cpp,sha256=qIDk37McMT5NFnK1071EJ5XO7gtukOEAyRfkZosSTLw,2184
+sidan_gin/python_signing_module/src/signer.h,sha256=8QVtsW-XjAka9nITanp1SHATwH44uVopBL3S9yOcD4s,986
+sidan_gin/python_signing_module/src/signer.i,sha256=P6iSLTLca1LPh4d04yQDl-Z8DDs3cMn29Q1bD2pyb7k,401
+sidan_gin/python_signing_module/src/signer_wrap.cxx,sha256=2pG1Vb5LEu5hzAPxWracx7BeRA1gLQRnqmflvJld3q4,124704
+sidan_gin/types/__init__.py,sha256=r5Z6Bto1lE22yhNO9UThri6xoSUnoKk1Gb9A8aHMI24,241
+sidan_gin/types/account_info.py,sha256=Q5TIXE6Ofj3DlSlMdeL2jhrSQYaJHIqhEzW_oMe_5OU,193
+sidan_gin/types/asset.py,sha256=9LXNaCIJ0lyA0sGJOnusb_hDRf_ODZK4b3onUZmMPfI,2088
+sidan_gin/types/asset_metadata.py,sha256=yRJ8irLcb-VCEeHHjIo_PZ74EL6HU_hp3oCfi2ak82Q,61
+sidan_gin/types/block_info.py,sha256=rNdI-ZyhrrYvmtn3TuV6UgGO_rp1naugQ5fftUmzaAA,341
+sidan_gin/types/network.py,sha256=HwUVx3IOllG42QwM1Pr81DNnJltJHcJz9aJeyXQGDQw,378
+sidan_gin/types/protocol.py,sha256=MxC2TLtQVrQao6csvPx459JwIpM98XNwBYK05d-JRA8,583
+sidan_gin/types/transaction_info.py,sha256=c7rh7I38uTksnyDgAZKPdLlw0zVeQHfIVWrcWw-IwrA,220
+sidan_gin/types/utxo.py,sha256=HvnAJXxyLm0KUBnrqprMm8Pc8H2ebxGW339pFLKo7K4,452
+sidan_gin/types/value.py,sha256=cGFqxk15FrG2zy6PB5zMRq1vOBYfBQbMWbuqiCTEgRg,3345
+sidan_gin/wallet/__init__.py,sha256=y_6mQqlePwnC0LPbCM0Il4XfkAzG0aqJLOdGRrSgljg,43
+sidan_gin/wallet/cli.py,sha256=R-Q2Sq_K2j7ctkvZ57iB0z1dlqsqSe8zSqR11OZEPzE,290
+sidan_gin/wallet/derivation_indices.py,sha256=NbxUEJfPgUCq6ACJtSbF4Zq8DtAO0vtjski7KtwvE9U,1139
+sidan_gin/wallet/mnemonic.py,sha256=z5Xxg9rPi_aGToiDOp49BimfUsNDnZcL9e6jAnW4-6A,908
+sidan_gin/wallet/root_key.py,sha256=V8PFx2FzEEgmLrhhD64Dw5yZB8OxRUFo99QsigWdsyQ,877
+sidan_gin/wallet/wallet.py,sha256=XXBF4AVgXZGhleKZNkUqR5610Qe8Ey03C44fd19KxYI,1920
+sidan_gin-0.1.7.dist-info/METADATA,sha256=ZOmwuz4t_FpCBFjr7lI_WUsib2WQfUAFUdD0jvHVSNA,2733
+sidan_gin-0.1.7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+sidan_gin-0.1.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sidan_gin-0.1.7.dist-info/RECORD,,

sidan_gin-0.1.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any