Python

Upstream iş məkanında Python SDK iroha-pythondir. İlk Iroha 3 buraxılışı mövcud Torii və Norito səthləri hədəfləyir. Birləşməniz tərəfindən istifadə olunan paket versiyasını və ya mənbə dəyişikliyini bağlayın ki, SDK və düyün eyni tel formatı dəyişikliyi ilə qalsın.

Aşağıda göstərilən yalnız oxunma nümunələri Taira ünvanında ictimai https://taira.sora.org ilə müqayisədə yoxlanılıb. Mutasiya nümunələri əməliyyat şablonlarıdır: onlar təqdim edilmədən əvvəl hədəf marşrutu tərəfindən tələb olunan real Taira səlahiyyət, xüsusi açar, qaz metadata və operator nömrələri lazımdır.

Bu sırada nümunələrdən istifadə edin:

Səhnə	İctimaiyyətə qarşı yarış Taira?	Sənə nə lazımdır?
Yalnız oxumaq üçün müştəri zəngləri	Bəli .	Python paket və şəbəkəyə giriş
Yerli imzalanma və təlimat qurucuları	`submit()` qədər şəbəkə zəngləri yoxdur.	Yerli uzantı və əsas materialınız
Transaksiya və xidmət çağırışlarının mübadiləsi	Yalnız öz maliyyələşdirilən hesabınızla.	Hökumət hesabı, xüsusi açar, zəncir ID, ödəniş metadataları, ödəniş aktivləri balansı və markalı işarələr
Çərçivə kodekləri, kripto və GPU köməkçilərini bağlayın	Yalnız yerli	Yerli uzantı; GPU köməkçilərin də CUDA-ə malik bir arxaya ehtiyacı var

Qurmaq

Paketin metadata adı iroha-pythondir. Əlavə edilməmiş PyPI quraşdırmanın canlı Taira şəbəkəsinə uyğun olduğunu düşünməyin. İnteqrasiya hədəflərinizdəki eyni yuxarı səviyyəli yenidənqurmadan qurulmuş bir təkər və ya mənbə verilişini quraşdırın:

bash

python -m pip install /path/to/iroha_python-*.whl

Layihəniz yuxarı axın iş məkanını birbaşa istehlak edərsə, Python asılılıqlarını quraşdırın və Instruction, TransactionDraft, imzalama, kripto, SoraFS yerli köməkçi, GPU köməkçi və ya Connect çərçivə kodekləri istifadə edən nümunələri işlətmədən əvvəl yerli uzantı qurun. Yükləmə komandanını yuxarıdan istifadə edin python/iroha_python/README.md, sonra yerli ixrac yükünün yoxlanılmasını:

bash

cd python/iroha_python
python - <<'PY'
from iroha_python import Instruction, generate_ed25519_keypair

print(Instruction)
print(generate_ed25519_keypair().public_key.hex())
PY

Əgər create_torii_client idxal, lakin Instruction və ya generate_ed25519_keypair uğursuzluğa məruz qalırsa, təmiz Python paketi mövcuddur, amma yerli uzantısı yoxdur.

Tez başlanğıc

İctimai, yalnız oxuna bilən Taira son nöqtələri ilə başlayın:

python

from iroha_python import (
    create_torii_client,
)

client = create_torii_client("https://taira.sora.org")

# Public reads do not need an authority or private key.
status = client.request_json("GET", "/status", expected_status=(200,))
accounts = client.list_accounts_typed(limit=5)

print(status["build"]["version"])
for account in accounts.items:
    print(account.id)

Paylaşılan quruluş

Bu quruluşu mutasiyalı şablonlar üçün istifadə edin. Göndərmədən əvvəl hər yer sahibini bir Taira səlahiyyət, şəxsi açar, token və aktiv / hesab IDs ilə əvəz edin.

authority əməliyyatı imzalayan hesabdır. private_key həmin hesabla, CHAIN_ID hədəf şəbəkə ilə uyğun olmalıdır və TX_METADATA şəbəkənin gözlədiyi ödəniş sahələrini daxil etməlidir. Aşağıdakı yer sahibləri məqsədyönlü olaraq etibarsızdırlar, buna görə də təsadüfi olaraq təqdim edilmirlər.

python

from iroha_python import (
    Ed25519KeyPair,
    Instruction,
    TransactionConfig,
    TransactionDraft,
    create_torii_client,
)

TORII_URL = "https://taira.sora.org"
CHAIN_ID = "fc56984b-2be7-431d-840e-21514d1883f0"
AUTH_TOKEN = None

# Replace these placeholders with the real signing keys for your accounts.
alice_pair = Ed25519KeyPair.from_private_key(bytes.fromhex("<alice-private-key-hex>"))
bob_pair = Ed25519KeyPair.from_private_key(bytes.fromhex("<bob-private-key-hex>"))

# The authority string must identify the same account as the private key.
alice = "<alice-account-id>"
bob = "<bob-account-id>"

ROSE_DEFINITION = "rose#wonderland"
ROSE_ASSET = "<rose-asset-id>"
BADGE_NFT = "badge$wonderland"

TX_METADATA = {
    # Public Taira fee asset. Use the configured XOR asset on your network.
    "gas_asset_id": "6TEAJqbb8oEPmLncoNiMRbLEK6tw",
}

client = create_torii_client(TORII_URL, auth_token=AUTH_TOKEN)


def submit(*instructions):
    # This is the network boundary: build, sign, submit, and wait for status.
    return client.build_and_submit_transaction(
        chain_id=CHAIN_ID,
        authority=alice,
        private_key=alice_pair.private_key,
        instructions=list(instructions),
        metadata=TX_METADATA,
        wait=True,
    )

Instruction.* yalnız konstruksiya təlimatının paylı yüklərini çağırır. submit() SDK əməliyyatın imzalanması, Torii ünvanına göndərilməsi və status gözləməsidir.

Fərdlər və qaz

Əməliyyatları yazmaq üçün ödəniş metadata və maliyyələşdirilmiş ödəniş aktivinin balansına ehtiyac var. Taira-də ödəniş varlığı ictimai faucet tərəfindən maliyyələșdirilir və əməliyyat metadatalarında gas_asset_id daxil olmalıdır.Minamoto-də ödəmələr real XOR ilə ödənir və aktiv ID həmin şəbəkənin konfigüratsiyasından gəlir.

Ödəniş metadataları ayrı-ayrı təlimatlara deyil, əməliyyatın payına düşür. Yuxarıda göstərilən submit() köməkçisi qurduğu hər bir əməliyyat üçün TX_METADATA əlavə edir:

python

TX_METADATA = {
    # Taira expects the fee asset definition in transaction metadata.
    "gas_asset_id": "6TEAJqbb8oEPmLncoNiMRbLEK6tw",
}

envelope, status = client.build_and_submit_transaction(
    chain_id=CHAIN_ID,
    authority=alice,
    private_key=alice_pair.private_key,
    # Fee metadata is attached to the transaction, not the instruction.
    instructions=[
        Instruction.set_account_key_value(
            alice,
            "python_fee_example",
            "ready",
        )
    ],
    metadata=TX_METADATA,
    wait=True,
)

Yazılar göndərməzdən əvvəl, idarə hesabının ödəniş aktivinin kifayət qədər olduğuna əmin olun. ID şəbəkə xüsusiyyətləri; bu, Taira forma:

python

FEE_ASSET_DEFINITION = "6TEAJqbb8oEPmLncoNiMRbLEK6tw"
# The faucet returns the concrete account asset ID to check here.
FEE_ASSET_ID = "<fee-asset-id-from-faucet-response>"
TX_METADATA = {"gas_asset_id": FEE_ASSET_DEFINITION}

# Fail before submitting if the signer cannot pay gas.
fee_assets = client.list_account_assets_typed(
    alice,
    limit=10,
    asset_id=FEE_ASSET_ID,
)
if not fee_assets.items:
    raise RuntimeError("fund the authority account with the Taira fee asset first")

Kovan betonları qaytaracaq. asset_id Tərəflərin balansı yoxlanılması üçün istifadə edilməlidir. gas_asset_id Metadata sahəsi ödəniş aktivinin tərifini istifadə edir. ID.

Bir əməliyyat qurarkən xəritələrin birləşdirilməsi ilə tətbiq metadatalarını ödəniş metadatalarından ayırın:

python

APP_METADATA = {"source": "python-docs"}
# Merge app metadata with required fee metadata before building the draft.
metadata = {**TX_METADATA, **APP_METADATA}

draft = TransactionDraft(
    TransactionConfig(
        chain_id=CHAIN_ID,
        authority=alice,
        metadata=metadata,
    )
)

Əgər ödəniş metadatalarını buraxırsınızsa, səhv ödəniş aktivindən istifadə edirsinizsə və ya maliyyələşdirilməmiş bir hesabla imza atsanız, həqiqi şəbəkə təlimat yükünün başqa cür etibarlı olsa da əməliyyatı rədd etməlidir.

Taira-Mühakimə olunmuş yalnız oxumaq üçün zənglər

Bu çağırışlar ictimaiyyətə Taira qarşı uğurla cavablandırılıb:

python

client = create_torii_client("https://taira.sora.org")

# Use raw requests for endpoints that do not need a typed wrapper.
status = client.request_json("GET", "/status", expected_status=(200,))
parameters = client.request_json("GET", "/v1/parameters", expected_status=(200,))

# Typed helpers parse pagination and records into dataclasses.
accounts = client.list_accounts_typed(limit=1)
domains = client.list_domains_typed(limit=1)
definitions = client.query_asset_definitions_typed(limit=1)

# These calls inspect live node subsystems without mutating state.
time_now = client.get_time_now_typed()
time_status = client.get_time_status_typed()
sumeragi = client.get_sumeragi_status_typed()
connect = client.get_connect_status_typed()

print(status["build"]["version"])
print(parameters["sumeragi"]["block_time_ms"])
print(accounts.total, domains.total, definitions.total)
print(time_now.now_ms, len(time_status.samples), sumeragi.leader_index)
print(connect.enabled, connect.sessions_active)

/v1/status, ictimai həmyaşıdların inventariyası, Sumeragi RBC nümunə götürülməsi, node admin sürətləndirmələri və Connect tətbiqetmələr qeydiyyatının idarə edilməsi kimi marşrutlar yoxlama zamanı ictimaiyyətə Taira verilmirdi. request_json("GET", "/status")-dən ictimai node status payload üçün istifadə edin Taira.

İnşaatçıların təlimatı

SDK ən çox yayılmış təlimat ailələri üçün tiplənmiş qurucuları və hələ birinci dərəcəli Python üsulları olmayan variantlar üçün JSON qaçış qapısı aşkar edir. Aşağıdakı hissələr mutasiyalı əməliyyat şablonlarıdır və imzalanmış hesab olmadan ictimaiyyətə Taira təqdim edilməmişdir.

Python dəyərlərini normallaşdırırlar və etibarsız formalarda erkən uğursuz olurlar. Instruction.from_json yalnız hələ Python köməkçisi olmayan bir təlim variantına ehtiyac duyduğunuzda istifadə edin.

Təlim ailəsi	Python səth
Qeydiyyat .	`register_account`, `register_asset_definition_numeric`, `register_rwa`, `register_time_trigger`, `register_precommit_trigger`; `register_domain` genesis/bootstrap vasitələri üçün nəzərdə tutulmuşdur.
qeydiyyatdan çıxarın.	`unregister_trigger`; digər variantlar üçün `Instruction.from_json` istifadə edin
Mint / Burn	`mint_asset_numeric`, `burn_asset_numeric`, `mint_trigger_repetitions`, `burn_trigger_repetitions`
Transfer	`transfer_asset_numeric`, `transfer_domain`, `transfer_asset_definition`, `transfer_nft`, `transfer_rwa`, `force_transfer_rwa`
Metadata və nəzarət	`set_account_key_value`, `remove_account_key_value`, `set_rwa_controls`, `set_rwa_key_value`, `remove_rwa_key_value`
RWA həyat dövrü	`merge_rwas`, `redeem_rwa`, `freeze_rwa`, `unfreeze_rwa`, `hold_rwa`, `release_rwa`
ExecuteTrigger	`execute_trigger`
Repo və ya məskunlaşma müddətinin uzadılması	`repo_initiate`, `repo_unwind`, `repo_margin_call`, `settlement_dvp`, `settlement_pvp`
Yerli aktivlərin kilidləri	`open_asset_lock`, `drawdown_asset_lock`, `cancel_asset_lock`, `expire_asset_lock` və əlavə olaraq müştərinin `*_and_wait` köməkçiləri
Grant/Revoque, SetParameter, Log, Custom, Upgrade və daha az yayılmış qeydiyyatdan keçmə variantları	`Instruction.from_json` və ya `TransactionBuilder.add_instruction_json`, kanonik `InstructionBox` JSON ilə

Yükləmə üslubunda şərti ödənişlər üçün bax Native Asset Escrow. Python hazırda ümumi aktivlərin qapanması üçün birinci dərəcəli köməkçiləri açıqlayır; bazar və anonim yükləmə yardımçıları hələ birinci dərəcəli Python metodları deyil.

Domenlər qurun, sonra hesablar və aktivlər qeydiyyatdan keçirin

Normal domen yaradılması deklarativ alias planlaşdırıcı vasitəsilə gedir ki, SNS Layihə, sahibkarlıq imkanları, qiymətləndirmə mühafizəsi və domen vəziyyətləri birlikdə yoxlanılır. AliasSetupPlanRequestV1 məqsədinizlə SDK ya da yükləmə xidməti, sonra istifadə edin iroha app alias setup plan və iroha app alias setup apply. İstifadə etməyin Instruction.register_domain bir tətbiq əməliyyatından; bu qurucusu genesis/bootstrap alətçiliyi üçün qalır.

Domen quraşdırma planının öhdəsindən gəldikdən sonra, domen mülkiyyətində olan obyektləri qeyd edin. Taira kimi paylaşılan şəbəkədə sizə təyin edilmiş bir domen və hesab ad məkanından istifadə edin.

python

# The domain and its SNS lease already exist before this transaction.
submit(
    Instruction.register_account(alice, {"display_name": "Alice"}),
    Instruction.register_account(bob, {"display_name": "Bob"}),
    Instruction.register_asset_definition_numeric(
        ROSE_DEFINITION,
        owner=alice,
        scale=2,
        mintable="Infinitely",
        confidential_policy="TransparentOnly",
        metadata={"symbol": "ROS"},
    ),
)

mintable qəbul edir Infinitely, Once, Not, və ya Limited(n) Məlumat modelləri tərəfindən qəbul edilmiş dəyərlər. scale məhdudlaşdırılmamış saylı aktiv üçün.

Mint, yandırma və köçürmə aktivləri

Bu çağırışlar mövcud bir aktivdən istifadə edir ID. Əvvəlcə aktivin tərifini qeyd edin, sonra aktivə sahib olan hesab üçün konkret aktiv ID qurun.

python

# Increase the account's asset balance.
submit(Instruction.mint_asset_numeric(ROSE_ASSET, "100.00"))

# Move part of the balance to another account.
submit(Instruction.transfer_asset_numeric(ROSE_ASSET, "25.50", bob))

# Decrease the remaining balance.
submit(Instruction.burn_asset_numeric(ROSE_ASSET, "10.00"))

Transfer mülkiyyəti

Mülkiyyət köçürmələri domeni kim idarə edir, aktivin tərifi və ya NFT. Müqavilənin icra hakimiyyəti olaraq mövcud sahibini istifadə edin.

python

# The first argument is the current owner; the last is the new owner.
submit(Instruction.transfer_domain(alice, "wonderland", bob))
submit(Instruction.transfer_asset_definition(alice, ROSE_DEFINITION, bob))
submit(Instruction.transfer_nft(alice, BADGE_NFT, bob))

Metadataları düzəltmək və çıxarmaq

Metadata dəyərləri JSON-serialləşdirilə bilər. TransactionDraft istifadə edərkən, TransactionConfig-dəki səlahiyyət standart hədəf hesabına çevrilir.

python

# Values are encoded as JSON metadata under the target account.
submit(
    Instruction.set_account_key_value(
        alice,
        "profile",
        {"display_name": "Alice", "tier": "operator"},
    )
)

# Removing the key deletes the metadata entry from the account.
submit(Instruction.remove_account_key_value(alice, "profile"))

Yüksək səviyyəli layihə köməkçisi əməliyyat orqanını default olaraq hədəfləyir:

python

draft = TransactionDraft(
    TransactionConfig(chain_id=CHAIN_ID, authority=alice, metadata=TX_METADATA)
)
# With a draft, account metadata methods default to the draft authority.
draft.set_account_key_value("nickname", "Queen Alice")
draft.remove_account_key_value("nickname")

Əsl dünya aktivləri

RWA köməkçiləri aktivə aid meta məlumatlar, mənşəlilik və nəzarətçi siyasəti üçün JSON seriallaşdırıla bilən pay yüklərindən istifadə edirlər. register_rwa bir id və ya owner qəbul etmir: iş vaxtı RwaId yaradır və əməliyyat orqanı ilkin sahibi olur.

python

draft = TransactionDraft(
    TransactionConfig(chain_id=CHAIN_ID, authority=alice, metadata=TX_METADATA)
)

# Register the lot in a domain. Store business identifiers in primary_reference
# or metadata, then query the generated RWA ID after the transaction commits.
draft.register_rwa(
    {
        "domain": "commodities.universal",
        "quantity": "100",
        "spec": {"scale": 0},
        "primary_reference": "warehouse-receipt-001",
        "status": "active",
        "metadata": {
            "commodity": "copper",
            "warehouse": "DXB-01",
        },
        "parents": [],
        "controls": {
            "controller_accounts": [alice],
            "controller_roles": [],
            "freeze_enabled": True,
            "hold_enabled": True,
            "force_transfer_enabled": True,
            "redeem_enabled": True,
        },
    }
)

Qeydiyyat əməliyyatının öhdəliklərini yerinə yetirdikdən sonra FindRwas, /v1/rwas, RWA hadisəsi və ya istehsal olunan ID kəşf etmək üçün təyin edilmiş tədqiqatçı marşrutu istifadə edin:

python

page = client.list_rwas_typed(limit=20, offset=0)

for lot in page.items:
    print(lot.id)

Sonrakı əməliyyatlarda istehsal olunan hash$domain ID istifadə olunur:

python

registered_rwa_id = (
    "0123456789abcdef0123456789abcdef"
    "0123456789abcdef0123456789abcdef$commodities.universal"
)

draft = TransactionDraft(
    TransactionConfig(chain_id=CHAIN_ID, authority=alice, metadata=TX_METADATA)
)

# Transfer, hold, release, freeze, and redeem model the lot lifecycle.
draft.transfer_rwa(
    registered_rwa_id,
    quantity="10",
    destination=bob,
)
draft.hold_rwa(registered_rwa_id, quantity="5")
draft.release_rwa(registered_rwa_id, quantity="5")
draft.freeze_rwa(registered_rwa_id)
draft.unfreeze_rwa(registered_rwa_id)
draft.redeem_rwa(registered_rwa_id, quantity="1")

# RWA metadata and controls are separate from account metadata.
draft.set_rwa_key_value(registered_rwa_id, "auditor", "alice")
draft.remove_rwa_key_value(registered_rwa_id, "auditor")
draft.set_rwa_controls(
    registered_rwa_id,
    {
        "controller_accounts": [alice],
        "controller_roles": [],
        "freeze_enabled": True,
        "hold_enabled": True,
        "force_transfer_enabled": True,
        "redeem_enabled": True,
    },
)

# Merge consumes quantities from parent lots with the same domain and spec. The
# child lot gets a generated ID.
draft.merge_rwas(
    {
        "parents": [
            {"rwa": registered_rwa_id, "quantity": "40"},
            {
                "rwa": "fedcba9876543210fedcba9876543210"
                "fedcba9876543210fedcba9876543210$commodities.universal",
                "quantity": "60",
            },
        ],
        "primary_reference": "warehouse-receipt-003",
        "status": "merged",
        "metadata": {"merge_reason": "same custodian and quality grade"},
    }
)

# Force transfer requires a configured controller and force_transfer_enabled.
draft.force_transfer_rwa(
    registered_rwa_id,
    quantity="1",
    destination=bob,
)

Tam köçürmələr mövcud partiyada owned_by dəyişə bilər. Qeyri-bərabər köçürmə və birləşmələr yaranmış uşaq lotları yaradır.

Triggerlər

İcra edilə bilən başqa bir təlimat ardıcıllığı olduğu zaman tetikləyici qeydiyyat köməkçilərindən istifadə edin:

python

# The trigger executable is just another instruction payload.
reward = Instruction.mint_asset_numeric(ROSE_ASSET, "1")

# Time triggers run on a schedule once registered.
register_hourly = Instruction.register_time_trigger(
    "hourly_reward",
    alice,
    [reward],
    start_ms=1_800_000_000_000,
    period_ms=3_600_000,
    repeats=24,
    metadata={"purpose": "docs"},
)
submit(register_hourly)

# Precommit triggers run during the transaction pipeline.
register_precommit = Instruction.register_precommit_trigger(
    "precommit_reward",
    alice,
    [reward],
    repeats=10,
    metadata={"purpose": "pipeline test"},
)
submit(register_precommit)

# Trigger execution and repetition changes are also transactions.
submit(Instruction.execute_trigger("hourly_reward", args={"reason": "manual"}))
submit(Instruction.mint_trigger_repetitions("hourly_reward", 5))
submit(Instruction.burn_trigger_repetitions("hourly_reward", 1))
submit(Instruction.unregister_trigger("hourly_reward"))

Torii həmçinin REST köməkçilərini tetikçi inventarı üçün açıqlayır:

python

# Inventory helpers are reads; they do not unregister or execute triggers.
registered = client.list_triggers_typed(limit=20)
for trigger in registered.items:
    print(trigger.id, trigger.authority)

details = client.get_trigger_typed("precommit_reward")

Trigger inventar zəngləri yalnız oxumaq və ya yoxlamaq trigger qeydlər. qeydiyyat, icra, təkrar dəyişikliklər və qeydiyyatdan çıxarmaq mutasiya əməliyyatlarıdır.

Qeydiyyat və məzənnə təyinatları

Repo və ikitərəfli nizamlanma köməkçiləri əl işlənmədən Norito faydalı yükləri olmadan domen xüsusi təlimat variantlarını əlavə edirlər:

python

from iroha_python import (
    RepoCashLeg,
    RepoCollateralLeg,
    RepoGovernance,
    SettlementAtomicity,
    SettlementExecutionOrder,
    SettlementLeg,
    SettlementPlan,
)

config = TransactionConfig(
    chain_id=CHAIN_ID,
    authority=alice,
    # Keep repo and settlement examples bounded by a short TTL.
    ttl_ms=120_000,
    metadata=TX_METADATA,
)
draft = TransactionDraft(config)

# Each repo leg describes one side of the financing agreement.
cash = RepoCashLeg(asset_definition_id="usd#wonderland", quantity="1000")
collateral = RepoCollateralLeg(
    asset_definition_id="bond#wonderland",
    quantity="1050",
    metadata={"isin": "ABC123"},
)
governance = RepoGovernance(haircut_bps=1500, margin_frequency_secs=86_400)

# Domain-specific draft methods append the corresponding instructions.
draft.repo_initiate(
    agreement_id="daily_repo",
    initiator=alice,
    counterparty=bob,
    cash_leg=cash,
    collateral_leg=collateral,
    rate_bps=250,
    maturity_timestamp_ms=1_704_000_000_000,
    governance=governance,
)
draft.repo_margin_call("daily_repo")
draft.repo_unwind(
    agreement_id="daily_repo",
    initiator=alice,
    counterparty=bob,
    cash_leg=cash,
    collateral_leg=collateral,
    settlement_timestamp_ms=1_704_086_400_000,
)

# DVP/PVP settlement plans encode ordering and atomicity for both legs.
delivery = SettlementLeg(
    asset_definition_id="bond#wonderland",
    quantity="10",
    from_account=alice,
    to_account=bob,
    metadata={"isin": "ABC123"},
)
payment = SettlementLeg(
    asset_definition_id="usd#wonderland",
    quantity="1000",
    from_account=bob,
    to_account=alice,
)
plan = SettlementPlan(
    order=SettlementExecutionOrder.PAYMENT_THEN_DELIVERY,
    atomicity=SettlementAtomicity.ALL_OR_NOTHING,
)

draft.settlement_dvp(
    settlement_id="trade_dvp",
    delivery_leg=delivery,
    payment_leg=payment,
    plan=plan,
    metadata={"desk": "rates"},
)
draft.settlement_pvp(
    settlement_id="trade_pvp",
    primary_leg=payment,
    counter_leg=delivery,
)

envelope = draft.sign_with_keypair(alice_pair)
client.submit_transaction_envelope_and_wait(envelope)

JSON Escape Hatch

Əgər a Python köməkçi hələ mövcud deyil, qidalanma kanonik məlumat modeli InstructionBox JSON ilə Instruction.from_json və ya birbaşa TransactionBuilder.add_instruction_json. Bu, tövsiyə olunan yoldur Grant, Revoke, SetParameter, Log, Custom, Upgrade, Tərəfdaş / rolu NFT qeydiyyatdan keçməyən və bu köməkçilər yazılana qədər trigger olmayan variantları qeydə almamışdır.

python

from iroha_python import Instruction, TransactionBuilder

# Copy this payload from Rust/CLI tooling or from a pinned data-model schema.
instruction_box_json = """
{
  "<InstructionVariant>": {
    "...": "..."
  }
}
"""

instruction = Instruction.from_json(instruction_box_json)
submit(instruction)

# Use TransactionBuilder when you need lower-level control than TransactionDraft.
builder = TransactionBuilder(CHAIN_ID, alice)
builder.set_metadata(TX_METADATA)
builder.add_instruction_json(instruction_box_json)
envelope = builder.sign(alice_pair.private_key)
client.submit_transaction_envelope_and_wait(envelope)

Yüklənmiş və ya şəffaf olmayan təlimatlar üçün qurğular saxlanmadan əvvəl JSON vasitəsilə geri-geri səyahət:

python

# Round trips are useful for validating fixtures generated by another tool.
payload = Instruction.mint_asset_numeric(ROSE_ASSET, "1").to_json()
same_instruction = Instruction.from_json(payload)
print(same_instruction.as_dict())

Transaction iş axını

İmzalanmadan əvvəl bir neçə təlimat hazırlayan tətbiqlər üçün TransactionDraft istifadə edin. Bir layihə ttl_ms, nonce və metadata kimi əməliyyat səviyyəsində parametrləri bir yerdə saxlamağa imkan verir, sonra bir dəfə imzalayın:

python

config = TransactionConfig(
    chain_id=CHAIN_ID,
    authority=alice,
    # TTL and nonce are transaction-level properties shared by all instructions.
    ttl_ms=120_000,
    nonce=1,
    metadata={**TX_METADATA, "source": "python-docs"},
)

draft = TransactionDraft(config)
# Draft methods append instructions but do not submit anything yet. Domain
# setup is a separate alias-planner flow and has already committed here.
draft.register_account(bob, metadata={"role": "user"})
draft.register_asset_definition_numeric(
    ROSE_DEFINITION,
    owner=alice,
    scale=2,
    mintable="Infinitely",
)
draft.mint_asset_numeric(ROSE_ASSET, "100")
draft.transfer_asset_numeric(ROSE_ASSET, "25", destination=bob)

# Signing freezes the draft into an envelope ready for Torii.
envelope = draft.sign_with_keypair(alice_pair)
receipt = client.submit_transaction_envelope(envelope)
status = client.wait_for_transaction_status(envelope.hash_hex(), timeout=30)
print(receipt, status)

Təftiş, audit və ya cüzdan ötürülməsi üçün müəyyənləşdirmə manifesti ixrac etmək:

python

import json
from pathlib import Path

# Manifests are review artifacts; they are not submitted by themselves.
manifest = draft.to_manifest_dict(include_creation_time=True)
print(json.dumps(manifest, indent=2))

Path("transaction_manifest.json").write_text(
    draft.to_manifest_json(indent=2, include_creation_time=True),
    encoding="utf-8",
)

Hədəf zolağı bunu tələb edərkən imzalanmadan əvvəl yolun məxfilik sübutunu əlavə edin:

python

# Attach the proof before signing so it is covered by the transaction hash.
draft.add_lane_privacy_merkle_proof(
    commitment_id=7,
    leaf=bytes.fromhex("aa" * 32),
    leaf_index=3,
    audit_path=[bytes.fromhex("bb" * 32), None, bytes.fromhex("cc" * 32)],
    proof_backend="halo2/ipa",
    proof_bytes=b"...proof bytes...",
    verifying_key_bytes=b"...verifying key bytes...",
)
envelope = draft.sign_with_keypair(alice_pair)

Suallar

Tiplənmiş sorğu köməkçiləri xam JSON lüğətləri əvəzinə məlumat siniflərini qaytarır. Başlamaq üçün ən asan yoldur, çünki SDK səhifə sahəsini və sizin üçün ümumi qeyd sahələrini araşdırır:

python

# Typed pages expose `.items` plus pagination metadata such as `.total`.
accounts = client.list_accounts_typed(limit=25, sort="id")
for account in accounts.items:
    print(account.id, account.metadata)

domains = client.list_domains_typed(limit=10)
definitions = client.query_asset_definitions_typed(limit=10)
print(domains.total, definitions.total)

Torii son nöqtəsinin hələ ki, çap edilmiş bir qabığı olmadığı zaman ümumi müraciət köməkçiləri istifadə edin:

python

# Drop to raw JSON when you need an endpoint before a typed helper exists.
payload = client.request_json("GET", "/v1/parameters", expected_status=(200,))
metrics = client.get_metrics(as_text=True)

Hesab ehtiyatları köməkçiləri SDK normallaşdırıcısı tərəfindən qəbul edilmiş hesab identifikatorunu tələb edirlər. Kanonik I105 hesabı IDs və ya silsilədəki ali adlardan istifadə edin; Bir blok kəşfiyyatçısı və ya xam son nöqtə ID -ni geri qaytarırsa, onu SDK rədd edirsə, bu köməkçiləri çağırmadan əvvəl onu kanonik bir hesabda ID həll edin:

python

# These helpers expect a canonical account ID or an alias the SDK can normalize.
assets = client.list_account_assets_typed(alice, limit=10)
transactions = client.query_account_transactions_typed(alice, limit=5)
permissions = client.list_account_permissions_typed(alice, limit=20)

print(len(assets.items), len(transactions.items), len(permissions.items))

Hadisələr

Streaming köməkçiləri JSON payloadları əvvəlcədən dekodlayır. SSE hadisə adına, id-ə ehtiyac duyduğunuzda with_metadata=True keçin, yenidən sınayın və xam payload. Ən son hadisənin ID-ini saxlamaq üçün EventCursor ilə cüt axını. Bu nümunələr canlı hadisələri gözləyir, buna görə də müvafiq hadisə axını aktivləşdirilmiş və aktiv olan bir dərəyə qarşı çalışdırın.

python

from iroha_python import DataEventFilter, EventCursor

# Narrow the stream to proof events with the expected backend and proof hash.
proof_filter = DataEventFilter.proof(
    backend="halo2/ipa",
    proof_hash_hex="deadbeef" * 8,
)

# Persist the latest SSE id so a reconnect can resume from the same point.
cursor = EventCursor()
for event in client.stream_events(
    filter=proof_filter,
    cursor=cursor,
    resume=True,
    with_metadata=True,
):
    print(event.id, event.event, event.data)
    break

for event in client.stream_trigger_events(trigger_id="hourly_reward", resume=True):
    print(event)
    break

for tx_event in client.stream_pipeline_transactions(status="Queued"):
    print(tx_event)
    break

Açıqlamalar və ünvanlar

SDK yerli uzantıda tərtib edilmiş hər bir imza alqoritmi üçün yerli imzalanma köməkçilərini aşkar edir. Bu köməkçilər Taira çağırmır, lakin özəl uzantı tələb edirlər:

python

from iroha_python import (
    ED25519_ALGORITHM,
    derive_confidential_keyset_from_hex,
    derive_keypair_from_seed,
    hash_blake2b_32,
    verify,
)
from iroha_python.address import AccountAddress

# Key derivation and signing are local; no network call is made here.
ed_pair = derive_keypair_from_seed(b"alice", ED25519_ALGORITHM)
signature = ed_pair.sign(b"payload")
assert verify(ED25519_ALGORITHM, ed_pair.public_key, b"payload", signature)

# Canonical AccountId/I105 identity is derived only from the controller key.
# This constructor currently requires `domain`; canonical identity ignores it
# and AccountAddress.from_account emits a domainless address.
address = AccountAddress.from_account(domain="wonderland", public_key=ed_pair.public_key)
print(address.canonical_hex())
print(address.to_i105(0x02F1))

# Confidential key helpers derive local viewing/spending material.
confidential = derive_confidential_keyset_from_hex("01" * 32)
print(confidential.as_hex())
print(hash_blake2b_32(b"payload").hex())

supported_crypto_algorithms() istifadə edin təkərinizin nəyi dəstəklədiyini görmək üçün. Ümumi köməkçilər kanonik alqoritm etiketlərindən istifadə edir və Ed25519, secp256k1, ML-DSA, GOST, BLS və SM2 üçün işləyirlər:

python

from iroha_python import (
    CryptoKeyPair,
    derive_keypair_from_seed,
    load_keypair,
    parse_private_key_multihash,
    parse_public_key_multihash,
    private_key_multihash,
    public_key_multihash,
    sign,
    supported_crypto_algorithms,
    verify,
)

message = b"iroha multi-algorithm signing"

# Iterate the algorithms compiled into the installed native extension.
for algorithm in supported_crypto_algorithms():
    keypair = derive_keypair_from_seed(f"docs:{algorithm}".encode(), algorithm)
    signature = keypair.sign(message)

    # Both the object method and the generic helper verify the same signature.
    assert keypair.verify(message, signature)
    assert verify(algorithm, keypair.public_key, message, signature)

    # Loading a private key should reconstruct the same public key.
    loaded = load_keypair(keypair.private_key, algorithm)
    assert loaded.public_key == keypair.public_key
    assert sign(algorithm, loaded.private_key, message) != b""

    # Prefixed multihashes carry the algorithm label with the key bytes.
    public_multihash = public_key_multihash(
        algorithm,
        keypair.public_key,
        prefixed=True,
    )
    private_multihash = private_key_multihash(
        algorithm,
        keypair.private_key,
        prefixed=True,
    )

    public_algorithm, public_key = parse_public_key_multihash(public_multihash)
    private_algorithm, private_key = parse_private_key_multihash(private_multihash)
    restored = CryptoKeyPair.from_private_key_multihash(private_multihash)

    # Round-trip checks catch mismatched algorithm labels or key encodings.
    assert public_algorithm == algorithm
    assert public_key == keypair.public_key
    assert private_algorithm == algorithm
    assert private_key == keypair.private_key
    assert restored == keypair

Çin SM Kriptoqrafiya

İndiki Python SDK hər ikisini də açıqlayır SM2 köməkçiləri və SM2-Specifik rahatlıq köməkçiləri. SM2 hədəf şəbəkəsi tərəfindən gözlənilən fərqləndirmə kimliyi:

python

from iroha_python import (
    SM2_ALGORITHM,
    SM2_DEFAULT_DISTINGUISHED_ID,
    derive_keypair_from_seed,
    derive_sm2_keypair_from_seed,
    sign,
    sign_sm2,
    verify,
    verify_sm2,
)

capabilities = client.get_node_capabilities_typed()
sm = capabilities.crypto.sm if capabilities.crypto else None
# Use the node's default SM2 distinguishing ID when the node advertises one.
distid = sm.sm2_distid_default if sm else SM2_DEFAULT_DISTINGUISHED_ID

# The SM2-specific helper accepts the distinguishing ID explicitly.
pair = derive_sm2_keypair_from_seed(bytes.fromhex("11" * 32), distid=distid)
message = b"iroha-sm2-example"
signature = pair.sign(message)

assert pair.verify(message, signature)
assert verify_sm2(pair.public_key, message, signature, distid=distid)
assert sign_sm2(pair.private_key, message, distid=distid) != b""

# The generic API works when you only need the canonical `sm2` label.
generic_pair = derive_keypair_from_seed(bytes.fromhex("22" * 32), SM2_ALGORITHM)
generic_signature = sign(SM2_ALGORITHM, generic_pair.private_key, message)
assert verify(SM2_ALGORITHM, generic_pair.public_key, message, generic_signature)

print(pair.public_key_sec1_hex)
print(pair.public_key_multihash)

crypto.sm.enabled sizə bildirir ki, node hazırkı siyasətində SM ailəsi alqoritmlərini qəbul edib-etmədiyini göstərir. Eyni reklamda SM hash siyasəti və sürətləndirmə statusu var ki, bu da SM2 xüsusi axınların aktivləşdirilməsinə qərar verərkən faydalıdır:

python

capabilities = client.get_node_capabilities_typed()

# `enabled` is the submit-time policy flag, not just local SDK support.
if capabilities.crypto and capabilities.crypto.sm.enabled:
    sm = capabilities.crypto.sm
    print(sm.default_hash)
    print(sm.allowed_signing)
    print(sm.acceleration.policy)
else:
    print("SM crypto is not enabled by this node")

İctimaiyyət Taira açıqlanmışdır SM yoxlama zamanı bacarıq reklamı, lakin SM Orada imzalanma məhdudlaşdırıldı. Onun reklam imzalama algoritmaları ed25519, secp256k1, və bls_normal, Buna görə də təslim olmayın. SM2-mümkünlük pay yükünün dəyişmədiyi təqdirdə, həmin yerləşdirilməyə imzalanmış əməliyyatlar.

GOST və Post-Quantum açarları

GOST R 34.10-2012-ci parametrlər dəstləri və ML-DSA (ml-dsa) post-kvant imzaları üçün ümumi kripto API istifadə edin. Eyni açar cütlüyü obyekti imzalanma, təsdiqləmə və çox hash ixracı ilə məşğul olur:

python

from iroha_python import (
    GOST_3410_2012_256_PARAMSET_A_ALGORITHM,
    GOST_3410_2012_256_PARAMSET_B_ALGORITHM,
    GOST_3410_2012_256_PARAMSET_C_ALGORITHM,
    GOST_3410_2012_512_PARAMSET_A_ALGORITHM,
    GOST_3410_2012_512_PARAMSET_B_ALGORITHM,
    ML_DSA_ALGORITHM,
    derive_keypair_from_seed,
    verify,
)
from iroha_python.address import AccountAddress

CHAIN_DISCRIMINANT = 0x02F1
message = b"iroha gost and post-quantum example"

# Crypto helpers use canonical labels; account addresses use compact aliases.
# Every `domain=` argument below is ignored when the canonical AccountId/I105
# address is encoded.
GOST_ADDRESS_ALIASES = {
    GOST_3410_2012_256_PARAMSET_A_ALGORITHM: "gost-256-a",
    GOST_3410_2012_256_PARAMSET_B_ALGORITHM: "gost-256-b",
    GOST_3410_2012_256_PARAMSET_C_ALGORITHM: "gost-256-c",
    GOST_3410_2012_512_PARAMSET_A_ALGORITHM: "gost-512-a",
    GOST_3410_2012_512_PARAMSET_B_ALGORITHM: "gost-512-b",
}

# Derive and verify one local keypair for every GOST parameter set.
for crypto_algorithm, address_algorithm in GOST_ADDRESS_ALIASES.items():
    keypair = derive_keypair_from_seed(
        f"docs:{crypto_algorithm}".encode(),
        crypto_algorithm,
    )
    signature = keypair.sign(message)

    assert verify(crypto_algorithm, keypair.public_key, message, signature)

    address = AccountAddress.from_account(
        domain="wonderland",
        public_key=keypair.public_key,
        # Account addresses use compact curve aliases for GOST parameter sets.
        algorithm=address_algorithm,
    )
    print(crypto_algorithm)
    print(address.canonical_hex())
    print(address.to_i105(CHAIN_DISCRIMINANT))
    print(keypair.prefixed_public_key_multihash)

# ML-DSA follows the same generic signing and address flow.
mldsa_keypair = derive_keypair_from_seed(b"docs:ml-dsa", ML_DSA_ALGORITHM)
mldsa_signature = mldsa_keypair.sign(message)
assert verify(ML_DSA_ALGORITHM, mldsa_keypair.public_key, message, mldsa_signature)
post_quantum_address = AccountAddress.from_account(
    domain="wonderland",
    public_key=mldsa_keypair.public_key,
    algorithm="ml-dsa",
)
print(post_quantum_address.canonical_hex())
print(post_quantum_address.to_i105(CHAIN_DISCRIMINANT))
print(mldsa_keypair.prefixed_public_key_multihash)

Qapı GOST və qrupun reklamlaşdırılmış imzalama alqoritmlərində kvantdan sonrakı axınlar. Gələcək uyğunluqlu alqoritm adları üçün xam qabiliyyət pay yükünü istifadə edin:

python

capabilities = client.request_json(
    "GET",
    "/v1/node/capabilities",
    expected_status=(200,),
)
crypto = capabilities.get("crypto", {})
sm = crypto.get("sm", {})
# Nodes advertise the signing algorithms they will accept for transactions.
allowed = set(sm.get("allowed_signing", []))

GOST_ALGORITHMS = {
    "gost3410-2012-256-paramset-a",
    "gost3410-2012-256-paramset-b",
    "gost3410-2012-256-paramset-c",
    "gost3410-2012-512-paramset-a",
    "gost3410-2012-512-paramset-b",
}

# Local support is not enough; submit only when the node advertises support.
supports_gost = bool(allowed & GOST_ALGORITHMS)
supports_post_quantum = "ml-dsa" in allowed
supports_sm2 = "sm2" in allowed and bool(sm.get("enabled", False))

print(supports_gost, supports_post_quantum, supports_sm2)

Əgər bir node sizə lazım olan alqoritmi reklamlamırsa, açarı yalnız yerli və ya offline iş axınları üçün istifadə edin. İctimai Taira yoxlama zamanı, GOST və ML-DSA yuxarıda olan Python kitabxanasında SDK kripto köməkçisi olaraq mövcud idi, lakin node tərəfindən əməliyyat imzalanması üçün reklam verilmədi.

Konfiqurasiya məlumatlı müştərilərin yaradılması

Tətbiqiniz fayldan qovşaq parametrlərini oxuduqda resolve_torii_client_config istifadə edin, lakin yenə də mühit və ya sınaq xüsusi sıfırlamalara ehtiyacınız var:

python

import json
from iroha_python import create_torii_client, resolve_torii_client_config

with open("iroha_config.json", "r", encoding="utf-8") as handle:
    raw_config = json.load(handle)

# Override only the fields that vary by environment.
resolved = resolve_torii_client_config(
    config=raw_config,
    overrides={"timeout_ms": 2_000, "max_retries": 5},
)

# Pass the resolved config into the same client constructor used elsewhere.
client = create_torii_client(
    raw_config.get("torii", {}).get("address", TORII_URL),
    resolved_config=resolved,
)

Kagemusha hazırlığı

Python SDK ümumi Torii istintaq köməkçisi vasitəsilə mövcud JSON hazırlıq marşrutu ilə əlaqə saxlaya bilər:

python

ASSET_DEFINITION_ID = "<canonical_asset_definition_id>"

readiness = client.request_json(
    "GET",
    "/v1/offline/readiness",
    params={"asset_definition_id": ASSET_DEFINITION_ID},
    headers={"Accept": "application/json"},
    expected_status=(200,),
)
print(readiness["ready"])
print(readiness["blockers"])

Python yazılmış Kagemusha top-up və ya redemption arxiv qurucularını aşkar etmir. Kanonik V4 arxivlərini qurmaq üçün Swift və ya JVM cüzdanından istifadə edin, sonra onları dəstəkləyən Kagemusha Torii müştəri vasitəsilə təqdim edin və sorğu aparın.

Əlavələr

Subscription köməkçiləri paylaşılan xidmətdən miras alınan zəngləri mutasiya edirlər. Torii istifadə edilən müştəri iroha_python.ToriiClient. İstifadə IDs və hədəf aldığınız şəbəkədə mövcud olan aktivlər.

python

# The plan defines billing cadence, retry policy, and usage pricing.
usage_plan = {
    "provider": alice,
    "billing": {
        "cadence": {
            "kind": "monthly_calendar",
            "detail": {"anchor_day": 1, "anchor_time_ms": 0},
        },
        "bill_for": {"period": "previous_period", "value": None},
        "retry_backoff_ms": 86_400_000,
        "max_failures": 3,
        "grace_ms": 604_800_000,
    },
    "pricing": {
        "kind": "usage",
        "detail": {
            "unit_price": "0.024",
            "unit_key": "compute_ms",
            "asset_definition": "usd#wonderland",
        },
    },
}

# The provider signs plan creation.
client.create_subscription_plan(
    authority=alice,
    private_key=alice_pair.private_key_hex,
    plan_id="compute#wonderland",
    plan=usage_plan,
)

# The subscriber signs subscription creation.
client.create_subscription(
    authority=bob,
    private_key=bob_pair.private_key_hex,
    subscription_id="sub-001",
    plan_id="compute#wonderland",
)

# Usage is recorded by the provider and then charged on demand.
client.record_subscription_usage(
    "sub-001",
    authority=alice,
    private_key=alice_pair.private_key_hex,
    unit_key="compute_ms",
    delta="3600000",
)
client.charge_subscription_now(
    "sub-001",
    authority=alice,
    private_key=alice_pair.private_key_hex,
)

Bağlantı

URIs bağlantısını qurun və təhlil edin və Taira tərəfindən açıqlanan ictimai Connect statusunu oxuyun:

python

from iroha_python.connect import ConnectUri, build_connect_uri, parse_connect_uri

# Connect URIs are what an app hands to a wallet to start a session.
uri = build_connect_uri(
    ConnectUri(
        sid="base64url-session-id",
        chain_id=CHAIN_ID,
        node="taira.sora.org",
    )
)
parsed = parse_connect_uri(uri)
# Status tells you whether the node currently exposes Connect.
status = client.get_connect_status_typed()

assert parsed.chain_id == CHAIN_ID
print(status.enabled, status.sessions_active)

Çərçivə kodekləri, sessiya açarının alınması və sessiyanın yaradılması yerli uzantı və Connect seans marşrutunu təmin etməyi tələb edir:

python

from iroha_python import (
    ConnectControlClose,
    ConnectControlOpen,
    ConnectDirection,
    ConnectFrame,
    ConnectPermissions,
    decode_connect_frame,
    encode_connect_frame,
    generate_connect_keypair,
)

# The app keypair is separate from the account key used for transactions.
connect_pair = generate_connect_keypair()
info = client.create_connect_session_info(
    {"role": "app", "sid": connect_pair.public_key.hex()}
)
print(info.app_uri, info.wallet_token, info.expires_at)

# Control frames negotiate permissions before encrypted messages are sent.
frame = ConnectFrame(
    sid=bytes.fromhex("01" * 32),
    direction=ConnectDirection.APP_TO_WALLET,
    sequence=1,
    control=ConnectControlOpen(
        app_public_key=connect_pair.public_key,
        chain_id=CHAIN_ID,
        permissions=ConnectPermissions(methods=["SIGN_REQUEST_TX"], events=[]),
    ),
)
payload = encode_connect_frame(frame)
assert decode_connect_frame(payload) == frame

# Closing the control channel is explicit and carries a reason code.
client.send_connect_control_frame(
    "base64url-session-id",
    ConnectControlClose(role="App", code=4100, reason="finished", retryable=False),
)

Təsdiqdən sonrakı mesajları statuslu sessiya ilə şifrələyin:

python

from iroha_python import (
    ConnectDirection,
    ConnectSession,
    ConnectSessionKeys,
    ConnectSignRequestRawPayload,
)

# Derive symmetric session keys from both parties' keys and the session ID.
keys = ConnectSessionKeys.derive(
    local_private_key=bytes.fromhex("11" * 32),
    peer_public_key=bytes.fromhex("22" * 32),
    sid=bytes.fromhex("33" * 32),
)
session = ConnectSession(
    sid=bytes.fromhex("33" * 32),
    keys=keys,
)
# Encrypt application payloads after the session is approved.
encrypted = session.encrypt_app_to_wallet(
    ConnectSignRequestRawPayload(domain_tag="SIGN", payload=b"hash")
)
state = session.snapshot_state().to_dict()
print(encrypted.sequence, state)

İdarəetmə, Runtime və Admin Surface

Bu yalnız oxunma çağırışları ictimaiyyətə qarşı uğurla qaytarıldı Taira:

python

client = create_torii_client("https://taira.sora.org")

# Governance reads return either current settings or typed not-found wrappers.
protected = client.get_protected_namespaces()
referendum = client.get_governance_referendum_typed("ref-1")
tally = client.get_governance_tally_typed("ref-1")
locks = client.get_governance_locks_typed("ref-1")
unlock_stats = client.get_governance_unlock_stats_typed()

print(protected, referendum.found)
print(tally.approve, list(locks.locks), unlock_stats.expired_locks_now)

# Runtime reads expose the active ABI and any pending upgrade records.
abi = client.get_runtime_abi_active_typed()
abi_hash = client.get_runtime_abi_hash_typed()
runtime_metrics = client.get_runtime_metrics_typed()
upgrades = client.list_runtime_upgrades_typed()
capabilities = client.get_node_capabilities_typed()

print(abi, abi_hash, runtime_metrics)
print(upgrades.total, capabilities.abi_version)

Runtime yüksəltmə köməkçiləri runtime yüksəldilməsi API tərəfindən istifadə olunan manifest formasını qəbul edirlər. Bunlar operator hərəkətləridir, buna görə onları yalnız hesabınızın və tokeninizin icazə verildiyi bir düyünlə qarşı istifadə edin:

python

admin = create_torii_client(
    TORII_URL,
    auth_token="admin-token",
api_token="torii-token",
)

# Propose creates the upgrade instructions; activation/cancel are operator actions.
upgrade = admin.propose_runtime_upgrade(
    {
        "name": "Refresh runtime provenance",
        "description": "Schedules a no-ABI-change runtime rollout.",
        "abi_version": 1,
        "abi_hash": "00" * 32,
        "added_syscalls": [],
        "added_pointer_types": [],
        "start_height": 1_500_000,
        "end_height": 1_500_256,
    }
)
print(upgrade["tx_instructions"])

admin.activate_runtime_upgrade("deadbeef" * 4)
admin.cancel_runtime_upgrade("feedface" * 4)

Status, konsensus və şəbəkə telemetriyası

python

# `/status` is the public node snapshot endpoint on Taira.
status = client.request_json("GET", "/status", expected_status=(200,))
print(status["blocks"], status["txs_approved"])

# Sumeragi and time endpoints expose consensus and clock diagnostics.
sumeragi = client.get_sumeragi_status_typed()
print(sumeragi.highest_qc.height, sumeragi.tx_queue.saturated)

time_now = client.get_time_now_typed()
time_status = client.get_time_status_typed()
for sample in time_status.samples:
    print(sample.peer, sample.last_offset_ms, sample.last_rtt_ms)
print(time_now.now_ms)

SoraFS, UAID və Kaigi köməkçilər

Bu köməkçilər hədəf qovşağı müvafiq Nexus/SORA son nöqtələrini aşkar edərkən mövcuddur. Boş siyahıları etibarlı bir cavab kimi qəbul edin: ictimaiyyət Taira nümunə manifesti və ya UAID üçün məlumat olmadan marşrut aktivləşdirilə bilər.

python

# SoraFS status queries are reads scoped by manifest and status.
por_status = client.get_sorafs_por_status(manifest_hex="ab" * 32, status="verified")
print(len(por_status))

# UAID helpers inspect wallet/data-space bindings for one identifier.
uaid = "aabb" * 16
bindings = client.get_uaid_bindings_typed(uaid)
manifests = client.list_space_directory_manifests_typed(
    uaid,
    dataspace=11,
    status="active",
)
print(len(bindings.dataspaces), len(manifests.manifests))

# Kaigi health summarizes relay availability when the route is enabled.
health = client.get_kaigi_relays_health_typed()
print(health.healthy_total, health.failovers_total)

Norito RPC və GPU Yardımçıları

Artıq Norito baytlarınız varsa və ikitərəfli Torii son nöqtəsinə zəng etməlisinizsə, NoritoRpcClient istifadə edin. Məsələn, əvvəlki əməliyyat şablonundan imzalanmış bir zarf tələb olunur:

python

from iroha_python import NoritoRpcClient, NoritoRpcConfig

# Use the binary RPC client for endpoints that expect Norito bytes.
with NoritoRpcClient(NoritoRpcConfig(TORII_URL, timeout=5.0)) as rpc:
    response_bytes = rpc.call("/v1/transaction", envelope.signed_transaction_versioned)
    print(len(response_bytes))

CUDA köməkçiləri None backend mövcud olmadıqda geri qaytarırlar, buna görə də tətbiqlər skalar tətbiqetmələrə qayıda bilər:

python

from iroha_python import bn254_add_cuda, cuda_available, poseidon2_cuda

# Always probe CUDA availability before calling optional GPU helpers.
if cuda_available():
    print(poseidon2_cuda(1, 2))
    print(bn254_add_cuda((1, 0, 0, 0), (2, 0, 0, 0)))

Hal-hazırda mövcud olan əhatə

Python SDK artıq aşağıdakılara köməkçiləri əhatə edir:

Torii göndərmə, status, sorğu və idarəetmə axınları
Ümumi ISI və domen xüsusi genişləndirmələr üçün tiplənmiş təlimat qurucuları
Transaksiya layihələri, manifestləri, imzalama və imzalanmış əməliyyat qovşağı iş axınları
axın hadisələri, filtrlər və bərpa edilə bilən kursorlar
ümumi Kagemusha hazırlıq giriş və Torii abunə köməkçiləri; yazılmış əlavə və ödəniş qurğuları açıqlanmır
Hesab ünvanı, bütün alqoritmlərin imzalanması köməkçiləri, bir çox hash-ə dair səfərlər, SM2, GOST, ML-DSA və BLS və məxfi açar idarəetməsi
URIs, seanslar, çərçivələr, şifrələmə köməkçileri və qeydiyyat idarəçisi bağlayın.
idarəetmə, icra vaxtının yüksəldilməsi, Sumeragi, node-admin, SoraFS, UAID və Kaigi son nöqtələrinin bağlamaları, burada node bu xüsusiyyətləri ifşa edir

Əvvəlki istinadlar

python/iroha_python/README.md
python/iroha_python/DESIGN.md
python/iroha_python/src/iroha_python

Bu sənədlər bağlanmış iş məkanının tənzimlənməsindəki Python səth üçün həqiqət mənbəyidir.

Python ​

Qurmaq ​

Tez başlanğıc ​

Paylaşılan quruluş ​

Fərdlər və qaz ​

Taira-Mühakimə olunmuş yalnız oxumaq üçün zənglər ​

İnşaatçıların təlimatı ​

Domenlər qurun, sonra hesablar və aktivlər qeydiyyatdan keçirin ​

Mint, yandırma və köçürmə aktivləri ​

Transfer mülkiyyəti ​

Metadataları düzəltmək və çıxarmaq ​

Əsl dünya aktivləri ​

Triggerlər ​

Qeydiyyat və məzənnə təyinatları ​

JSON Escape Hatch ​

Transaction iş axını ​

Suallar ​

Hadisələr ​

Açıqlamalar və ünvanlar ​

Çin SM Kriptoqrafiya ​

GOST və Post-Quantum açarları ​

Konfiqurasiya məlumatlı müştərilərin yaradılması ​

Kagemusha hazırlığı ​

Əlavələr ​

Bağlantı ​

İdarəetmə, Runtime və Admin Surface ​

Status, konsensus və şəbəkə telemetriyası ​

SoraFS, UAID və Kaigi köməkçilər ​

Norito RPC və GPU Yardımçıları ​

Hal-hazırda mövcud olan əhatə ​

Əvvəlki istinadlar ​

Python

Qurmaq

Tez başlanğıc

Paylaşılan quruluş

Fərdlər və qaz

Taira-Mühakimə olunmuş yalnız oxumaq üçün zənglər

İnşaatçıların təlimatı

Domenlər qurun, sonra hesablar və aktivlər qeydiyyatdan keçirin

Mint, yandırma və köçürmə aktivləri

Transfer mülkiyyəti

Metadataları düzəltmək və çıxarmaq

Əsl dünya aktivləri

Triggerlər

Qeydiyyat və məzənnə təyinatları

JSON Escape Hatch

Transaction iş axını

Suallar

Hadisələr

Açıqlamalar və ünvanlar

Çin SM Kriptoqrafiya

GOST və Post-Quantum açarları

Konfiqurasiya məlumatlı müştərilərin yaradılması

Kagemusha hazırlığı

Əlavələr

Bağlantı

İdarəetmə, Runtime və Admin Surface

Status, konsensus və şəbəkə telemetriyası

SoraFS, UAID və Kaigi köməkçilər

Norito RPC və GPU Yardımçıları

Hal-hazırda mövcud olan əhatə

Əvvəlki istinadlar