Python

Ҡоролтай Python SDK өҫкө ағымындағы эш урынында iroha-python. Тәүгеһе Iroha 3 сығарыу маҡсаттары ағымдағы Torii һәм Norito өҫкө йөҙҙәр. һылтанма версияһы йәки сығанаҡ үҙгәртеп ҡороу һеҙҙең интеграция өсөн ҡулланылған SDK һәм узел бер үк сым форматында үҙгәртеүҙә ҡала.

Түбәндәге уҡырға ғына мөмкин булған миҫалдар асыҡ Taira менән https://taira.sora.org тикшерелде. Мутацияланған миҫалдарҙың береһе - транзакция өлгөләре: уларҙы тапшырыуҙан алда ысын Taira хоҡуғы, шәхси асҡыс, газ метамәғлүмәттәре һәм маҡсатлы маршрут талап иткән оператор токендары кәрәк.

Миҫалдарҙы ошо тәртиптә килтерегеҙ:

Этап	Taira халыҡҡа ҡаршы йүгереү?	Һеҙгә нимә кәрәк ?
Уҡыу өсөн генә клиенттар шылтыратыуы	Эйе .	Python пакет плюс селтәргә инеү
Урындағы ҡултамға төҙөүселәр һәм инструкторҙар	`submit()` тиклем селтәргә шылтыратыу юҡ.	Тыуған өлгөрөү һәм төп материал
Транзакцияларҙы һәм хеҙмәт саҡырыуҙарын күсереү	Үҙегеҙҙең аҡсалата иҫәбенә генә файҙаланығыҙ .	Хакимиәттең иҫәбенә, шәхси асҡысы, ID сылбыры, түләү метамәғлүмәттәре, түләү активтары балансы һәм маршрут токендары
Фрейм кодектары, крипто һәм GPU ярҙамсылары тоташтырығыҙ	Урындағы ғына	GPU ярҙамсыларына шулай уҡ CUDA һәләтле backend кәрәк.

Инсталляция

Пакеттың метамәғлүмәт исеме iroha-python. Ябайлаштырылған PyPI ҡуйыу тере Taira селтәренә тап килә тип уйламағыҙ. Интеграция маҡсаттарығыҙҙы бер үк өҫкө ағымынан төҙөлгән тәгәрмәс йәки сығанаҡ иҫкәртеүен ҡуйығыҙ:

bash

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

Әгәр һеҙҙең проект туранан-тура өҫкө йүнәлештәге эш киңлеген ҡуллана икән, Python бәйлелектәрен урынлаштырығыҙ һәм Instruction, TransactionDraft, ҡултамғалау, крипто, SoraFS урындағы ярҙамсылары, GPU ярҙамсылары йәки Connect рамка кодектары ҡулланылған миҫалдарҙы эшләтер алдынан туғандаш ҡушымтаны төҙөгөҙ. Өҫкө ағымынан build командаһын ҡулланығыҙ python/iroha_python/README.md, һуңынан төп экспорт йөкләнеүен тикшерегеҙ:

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

Әгәр create_torii_client импорты үтәлмәй, әммә Instruction йәки generate_ed25519_keypair уңышһыҙлыҡҡа осраһа, саф Python пакеты бар, ләкин урындағы оҙайтыу юҡ.

Тиҙерәк старт

Йәмәғәт, уҡырға ғына мөмкин булған Taira һуңғы нөктәләре менән башларға:

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)

Бергә урынлаштырыу

Мутацияланған шаблондар өсөн ошо көйләүҙе ҡулланығыҙ. тапшырыу алдынан һәр урынды Taira авторитеты, шәхси асҡысы, токен һәм актив / иҫәп-хисапҡа IDs алмаштырығыҙ.

authority - транзакцияға ҡул ҡуйған иҫәп. private_key был иҫәбкә тап килергә тейеш, CHAIN_ID маҡсатлы селтәргә тап килергә тейеш һәм TX_METADATA селтәр көтөп алған түләү өлкәләрен үҙ эсенә алырға тейеш. Түбәндәге урынды биләүселәр атайлап юҡҡа сығарылған, шуға күрә улар осраҡлы рәүештә тапшырылмай.

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.* бары тик конструкция инструкцияһы файҙалы йөкләмәләрен саҡыра. submit() - был пунктта SDK транзакцияны ҡул ҡуя, уны Torii адресына ебәрә һәм статусты көтә.

Һалымдар һәм газ

Транзакцияларҙы яҙыу өсөн түләү метамәғлүмәттәре һәм финансланған түләү активтары балансы кәрәк. Taira-ла, түләү активы йәмәғәт краны тарафынан финанслана һәм транзакция метамәғлимәттәрендә gas_asset_id булырға тейеш. Minamoto-ла түләүҙәр ысын XOR менән түләнә, ә актив ID был селтәрҙең конфигурацияһынан килә.

Һалым метамәғлүмәттәре айырым күрһәтмәләр буйынса түгел, ә транзакцияға ҡарай. юғарыла submit() ярҙамсыһы төҙөгән һәр операцияға TX_METADATA ҡуша:

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,
)

Яҙыуҙар ебәрер алдынан, хакимиәт иҫәбенә түләү активтарының етерлек булыуын тикшерегеҙ. Төп кран һәм актив ID селтәргә хас; был Taira формаһы:

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")

Һыуыҡ бетонды кире ҡайтара asset_id баланс тикшереү өсөн ҡулланырға. gas_asset_id метамәғлүмәт өлкәһендә түләү активтары билдәләмәһе ҡулланыла ID.

Транзакция төҙөгәндә карталарҙы берләштереү юлы менән заявканың метамәғлүмәттәре түләүҙең метамәғлимәттәренән айырым һаҡлана:

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,
    )
)

Әгәр һеҙ түләү метамәғлүмәттәрен ҡалдырһағыҙ, хаталы түләү активын ҡулланһағыҙ йәки финансламаған иҫәп-хисап менән ҡул ҡуйһағыҙ, реаль селтәр транзакцияны кире ҡағырға тейеш, хатта инструкция йөкләмәһе башҡаса ғәмәлдә булһа ла.

Taira - Тикшерелгән уҡырға ғына шылтыратыуҙар

Был саҡырыуҙар Taira йәмәғәтселеккә ҡаршы уңышлы кире ҡайтарылды:

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, йәмәғәт тиңдәшлек инвентары, Sumeragi RBC өлгөһө алыу, узел администраторы һынылыштар һәм Connect ҡушымталар реестры хакимиәте кеүек маршруттар тикшереү ваҡытында Taira сайтында асыҡтан-асыҡ ҡулланылмаған. request_json("GET", "/status") менән ҡулланыу Taira буйынса асыҡ узел статусы йөкләмәһе өсөн файҙалы.

Төҙөүселәргә күрһәтмәләр

Ҡоролтай SDK иң киң таралған инструкция ғаиләләр өсөн типлаштырылған төҙөүселәр һәм JSON Беренсе класлы булмаған варианттар өсөн ҡотолоу люкаһы Python Төмәндәге өҙөктәр - мутациялы транзакция өлгөләрен һәм улар асыҡланмаған Taira Ҡул ҡуйыу өсөн иҫәп юҡ.

Типталы ярҙамсыларға өҫтөнлөк бирәләр: улар нормализациялана Python ҡиммәттәре һәм ғәмәлһеҙ формаларҙа иртәрәк уңышһыҙлыҡ. Instruction.from_json тик инструкция варианты кәрәк саҡта ғына Python ярҙамсыһы әле.

Уҡытыу ғаиләһе	Python йөҙө
Регистрация	`register_account`, `register_asset_definition_numeric`, `register_rwa`, `register_time_trigger`, `register_precommit_trigger`; `register_domain` genesis/bootstrap инструменттары өсөн тәғәйенләнгән
Теркәлмәгеҙ	`unregister_trigger`; башҡа варианттар өсөн ҡулланыу `Instruction.from_json`
Минт/Борн	`mint_asset_numeric`, `burn_asset_numeric`, `mint_trigger_repetitions`, `burn_trigger_repetitions`
Трансфер	`transfer_asset_numeric`, `transfer_domain`, `transfer_asset_definition`, `transfer_nft`, `transfer_rwa`, `force_transfer_rwa`
Метамәғлүмәттәр һәм контроль	`set_account_key_value`, `remove_account_key_value`, `set_rwa_controls`, `set_rwa_key_value`, `remove_rwa_key_value`
RWA тормош циклы	`merge_rwas`, `redeem_rwa`, `freeze_rwa`, `unfreeze_rwa`, `hold_rwa`, `release_rwa`
ExecuteTrigger	`execute_trigger`
Репо/расселле киңәйтеүҙәре	`repo_initiate`, `repo_unwind`, `repo_margin_call`, `settlement_dvp`, `settlement_pvp`
Тыуған активтарҙы бикләү	`open_asset_lock`, `drawdown_asset_lock`, `cancel_asset_lock`, `expire_asset_lock`, өҫтәүенә клиентҡа ярҙам итеүселәр `*_and_wait`
Grant/Revocate, SetParameter, Log, Custom, Upgrade, һәм ҡағиҙә булараҡ теркәлгән / теркәлмәгән варианттар	`Instruction.from_json` йәки `TransactionBuilder.add_instruction_json` ҡануниally `InstructionBox` JSON

Эскор формаһындағы шартлы түләүҙәр өсөн ҡарағыҙ Башҡорт активтары эскоры. Python әлеге ваҡытта дөйөм активтарҙы ябыу өсөн беренсе класлы ярҙамсыларҙы асыҡлай; баҙар һәм аноним эскор ярҙамсылары әлегә беренсе класлы Python алымдар түгел.

Домендар булдырығыҙ, ә һуңынан иҫәптәр һәм активтар теркәгеҙ

Ғәҙәти домен булдырыу декларатив псевдонимы планер аша үтә, шуға күрә SNS ҡуртымға алыу, хужа мөмкинлектәрен, цитата һаҡлау һәм домен торошо бергә тикшерелә. AliasSetupPlanRequestV1 маҡсаты менән һеҙҙең SDK йәки инеү сервисы, һуңынан ҡулланыу iroha app alias setup plan һәм iroha app alias setup apply. Баҫмағыҙ Instruction.register_domain ҡулланыу транзакцияһынан; был төҙөүсе остается для генезис/bootstrap инструментов.

Домен булдырыу планы раҫланғандан һуң, доменға ҡараған объекттарҙы теркәгеҙ. Taira кеүек уртаҡ селтәрҙә һеҙгә тәғәйенләнгән домен һәм иҫәп-хисап исемдәр арауығын ҡулланығыҙ.

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 ҡабул итә Infinitely, Once, Not, йәки Limited(n) Мәғлүмәт моделе ҡабул ителгән ҡиммәттәр. scale сикләнмәгән һанлы актив өсөн.

Минет, яндырылған һәм күсерелгән мөлкәт

Был саҡырыуҙар ғәмәлдә булған активты ҡуллана ID. Тәүҙә активтың билдәләмәһен теркәп, һуңынан конкрет активты төҙөй. ID актив хужаһы булған иҫәпкә.

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"))

Трансфер биләмәһе

Хужалыҡ күсереүҙәр үҙгәрә кем доменды контролдә тота, актив билдәләмәһе йәки NFT. ғәмәлдәге хужаны транзакция власы булараҡ ҡулланырға.

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))

Метамәғлүмәттәрҙе йыйыу һәм алып ташлау

JSON-сериализацияланған метамәғлүмәт ҡиммәттәренә эйә булырға тейеш. һеҙ TransactionDraft ҡулланғанда, TransactionConfig-ҙағы власть default маҡсатлы иҫәпкә әйләнә.

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"))

Юғары кимәлдәге проект ярҙамсыһы күләмһеҙ рәүештә транзакция власына йүнәлтелгән:

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")

Реаль донъя активтары

RWA ярҙамсылары актив-специфик метамәғлүмәттәр, килеп сығыу һәм контроллер сәйәсәте өсөн JSON сериялаштырыла торған файҙалы йөкләмәләрҙе ҡуллана. register_rwa id йәки owner ҡабул итмәй: үтәү ваҡыты RwaId тыуҙыра, ә транзакция органы башланғыс хужа була.

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,
        },
    }
)

Теркәлеү операцияһы йөкләмәләрен үтәгәндән һуң, FindRwas, /v1/rwas, RWA ваҡиғаһын йәки генерацияланған ID табыу өсөн ҡуйылған эҙләүсе маршрутын ҡулланығыҙ:

python

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

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

Артабанғы операцияларҙа барлыҡҡа килгән hash$domain ID ҡулланыла:

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,
)

Тулы күсереүҙәр ғәмәлдәге партияла owned_by үҙгәрә ала. Өҫтәмә күсеүҙәр һәм берләшеүҙәр һөҙөмтәһендә балаларҙың күплеге барлыҡҡа килә.

Ҡатҡандар

Ҡулланырға trigger теркәү ярҙамсылары, әгәр башҡарыу ҡушымтаһы башҡа инструкция эҙмә-эҙлекле:

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 шулай уҡ REST ярҙамсыларын ҡуҙғатҡыс инвентарь өсөн асыҡлай:

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")

Стриггерҙар исемлеге шылтыратыуҙары тик уҡырға йәки тикшереү өсөн генә. Теркәү, башҡарыу, ҡабатлау үҙгәртеүҙәре һәм теркәүҙән баш тартыу - мутациялы операциялар.

Репо һәм иҫәп-хисап буйынса күрһәтмәләр

Репо һәм ике яҡлы хәл итеү ярҙамсылары ҡул менән эшләнмәгән Norito файҙалы йөкләмәләрһеҙ доменға ярашлы инструкция варианттарын өҫтәй:

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 Ҡотҡарылыу капкаһы

Әгәр Python ярҙамсыһы әлегә юҡ, аҙыҡ-түлек каноник мәғлүмәттәр моделе InstructionBox JSON үҙ эсенә Instruction.from_json йәки туранан-тура TransactionBuilder.add_instruction_json. Был тәҡдим ителгән юл Grant, Revoke, SetParameter, Log, Custom, Upgrade, тиңдәшлек/ роле/NFT теркәү, һәм триггер булмаған теркәлмәгән варианттар шул ярҙамсылары тип яҙылғанға тиклем.

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)

Яратҡан йәки үтә күренмәле булмаған күрһәтмәләр өсөн JSON аша ҡайтыу һәм урынлаштырыуҙан алда:

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())

Транзакциялар эш ағымдары

TransactionDraft ҡул ҡуйыу алдынан бер нисә инструкция төҙөгән ҡушымталар өсөн ҡулланығыҙ. Проект һеҙгә транзакция кимәлендәге көйләүҙәрҙе, мәҫәлән ttl_ms, nonce һәм метамәғлүмәттәрҙе бер урында һаҡларға мөмкинлек бирә, һуңынан бер тапҡыр ҡул ҡуйығыҙ:

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)

Тикшереү, аудит йәки аҡса янсығы тапшырыу өсөн детерминистик манифесты экспортлау:

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",
)

Әгәр маҡсатлы юл кәрәк булһа, ҡултамға ҡуйыу алдынан линейканың конфиденциаллығын иҫбатлауҙы ҡуйып тороғоҙ:

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)

Һорауҙар

JSON һүҙлектәре урынына типланған һорау ярҙамсылары мәғлүмәт кластары кире ҡайтара. Улар башлауҙың иң ябай ысулы, сөнки SDK страницаларҙы һәм дөйөм яҙма ҡырҙарын анализлай:

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 һуңғы нөктәһендә әле типланған төргәк булмағанда, дөйөм һорау ярҙамсыларын ҡулланығыҙ:

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)

Бухгалтер иҫәбенә инвентарь ярҙамсылары өсөн иҫәп-хисап идентификаторы SDK нормализатор.Канникаль ҡулланығыҙ I105 иҫәбенә IDs йәки селтәрҙәге ҡушаматтар; әгәр блоктарҙы тикшереүсе йәки сыма һуңғы пункт кире ҡайтарыусы ID тип SDK кире ҡаҡһа, уны каноник иҫәпкә һалалар. ID Яҡшы ярҙамсыларҙы саҡырыр алдынан:

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))

Ваҡиғалар

Стриминг ярҙамсылары JSON файҙалы йөкләмәләрен декодлай. with_metadata=True тапшырыуҙы үтәгеҙ, әгәр һеҙгә SSE ваҡиға исеме, идентификаторы, ҡабаттан һынап ҡарау һылтанмаһы һәм сей файҙалы йөкләнеш кәрәк булһа. Һуңғы ваҡиға ID-һын һаҡлап ҡалыу өсөн EventCursor менән берләштерегеҙ. Был миҫалдар тере ваҡиғалар көтөп тора, шуға күрә уларҙы тейешле ваҡиға ағымы булдырылған һәм әүҙем булған узелға ҡаршы йүгерергә.

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

Ключтар һәм адрестар

SDK һәр ҡултамға алгоритмы өсөн урындағы имзалау ярҙамсыларын асыҡлай. был ярҙамсылар Taira саҡыра алмай, әммә улар өсөн тыуған киңәйтеү кәрәк:

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() ҡулланып, тәгәрмәсегеҙ нимәгә булышлыҡ итә икәнен күрерһегеҙ. Дөйөм ярҙамсылары каноник алгоритм этикеткаларын ҡуллана һәм Ed25519, secp256k1, ML-DSA, GOST, BLS һәм SM2 өсөн эшләй:

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

Ҡытай SM Криптографияһы

Ҡоролтай Python SDK дөйөм икеһе лә асыҡлана SM2 ярҙамсылары һәм SM2-ҡайһы уңайлылыҡ ярҙамсылары. SM2 маҡсатлы селтәр көтөп алған айырымлау идентификаторы:

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 индексы үҙенең ағымдағы сәйәсәтендә SM-ауылы алгоритмдарын ҡабул итәме, юҡмы икәнен күрһәтә. Шул уҡ реклама SM хеш сәйәсәтен һәм тиҙләтеү статусын үҙ эсенә ала, был SM2-махсус ағымдарҙы булдырыуҙы хәл иткәндә файҙалы:

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")

Йәмәғәтселек Taira асыҡланған SM тикшереү барышында мөмкинлектәре тураһында иғлан, әммә SM там ҡултамғаһы һүндерелгән. уның рекламалы ҡултамға алгоритмдары ed25519, secp256k1, һәм bls_normal, Шуға күрә буйһонмағыҙ . SM2-был урынлаштырыу өсөн ҡул ҡуйылған транзакциялар, әгәр мөмкинлектәрҙең файҙалы йөкләмәһе үҙгәрмәй икән.

GOST һәм "Кванттан һуңғы асҡыстар"

Дөйөм крипто ҡулланыу API өсөн GOST R 34.10-2012 параметрҙар йыйылмалары һәм ML-DSA (ml-dsa) пост-квант ҡултамғалары. шул уҡ асҡыс пар объекты ҡултамға, тикшереү һәм күп hash экспорты менән шөғөлләнә:

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)

Gate GOST һәм кванттан һуңғы ағымдар узелдың рекламалы ҡултамғалау алгоритмдары буйынса. Алға ярашлы алгоритм исемдәре өсөн сыман мөмкинлектәрҙең файҙалы йөкләмәһен ҡулланығыҙ:

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)

Әгәр узел кәрәкле алгоритмды иғлан итмәй икән, был асҡысты локаль йәки офлайн эш ағымдары өсөн генә ҡулланығыҙ. Йәмәғәт Taira тикшереүе ваҡытында, GOST һәм ML-DSA SDK крипто ярҙамсылары булып Python юғары ағымындағы китапханала булған, әммә транзакцияларға ҡул ҡуйыу өсөн узел тарафынан иғлан ителмәгән.

Конфигурацияланған клиенттар булдырыу

Файлдан узел көйләмәләрен уҡығанда resolve_torii_client_config ҡулланһағыҙ, әммә барыбер мөхиткә йәки һынауға ҡарата өҫтөнлөклө талаптарға мохтаж:

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,
)

Кагемуша әҙерлеге

Python SDK үҙенең генераль Torii заявка ярҙамсыһы аша ағымдағы JSON әҙерлек маршрутын һорарға мөмкин:

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 типланған Кагемуша тулыландырыу йәки ҡайтарыу архив төҙөүселәрҙе фаш итмәй. Swift йәки JVM тип яҙылған аҡса янсығын ҡулланып, каноник V4 архивтарын төҙөйһөгөҙ, һуңынан уларҙы Kagemusha Torii клиент аша тапшырығыҙ һәм һорау алыу үткәргеҙ.

Абонементтар

Абонент ярҙамсылары бүлештерелгән сервис шылтыратыуҙарын мутациялай Torii ҡулланыусы клиент iroha_python.ToriiClient. Ҡулланыу IDs һәм һеҙ маҡсат итеп ҡуйған селтәрҙә булған активтар.

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,
)

Ҡатнашыу

URIs тоташтырыуҙы төҙөү һәм анализлау, һәм Taira асыҡ тоташыу статусын уҡыу:

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)

Фрейм кодектары, сеанс асҡысын сығарыу һәм сеанс төҙөү өсөн туғандаш киңәйтеү һәм Connect сеансы маршруты кәрәк:

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),
)

Белем алыуҙан һуң хәбәрҙәрҙе хәлдең торошо менән шифрлау:

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)

Идара итеү, идара итеү ваҡыты һәм администраторҙар өҫкө йөҙө

Был уҡырға ғына саҡырыуҙар 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)

Уйын ваҡыты яңыртыу ярҙамсылары ғәмәлгә ашырыу ваҡытын яңыртыу API ҡулланылған манифест формаһын ҡабул итә. Улар оператор хәрәкәттәре, шуға күрә уларҙы һеҙҙең иҫәбенә һәм токен рөхсәт ителгән узелға ҡаршы ғына файҙаланығыҙ:

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)

Статусы, консенсус һәм селтәр телеметрияһы

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 һәм Kaigi ярҙамсылары

Был ярҙамсылар маҡсатлы узел тейешле Nexus/SORA буш исемлектәрҙе дөрөҫ яуап итеп ҡабул итегеҙ: йәмәғәт Taira пробка өсөн мәғлүмәттәрһеҙ маршрут булдырылған булырға мөмкин, йәки UAID.

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 һәм GPU Ярҙамсылары

NoritoRpcClient ҡулланығыҙ, әгәр һеҙҙә Norito байттар бар һәм бинар Torii һуңғы нөктәһен саҡырырға кәрәк. Миҫалға элекке транзакция өлгөһөнән ҡул ҡуйылған конверт талап ителә:

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 ярҙамсылары backend булмағанда None кире ҡайтарыр, шуға күрә ғаризалар скаляр тормошҡа ашырыуҙарға кире төшә:

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)))

Хәҙерге яҡтыртыу

Python SDK инде түбәндәге ярҙамсыларҙы үҙ эсенә ала:

Torii тапшырыу, статус, һорау һәм идара итеүсе ағымдары
дөйөм ISI һәм доменға ярашлы киңәйтеүҙәр өсөн типлаштырылған инструкция төҙөүселәре
Транзакция проекттары, манифесттар, ҡултамғалау һәм ҡул ҡуйылған транзакция конверты эш ағымдары
трансляция ваҡиғалары, фильтрҙар һәм ҡабаттан башларға мөмкин булған курсорҙар
дөйөм Kagemusha әҙерлек инеү һәм Torii абонемент ярҙамсылары; типталған өҫтәмә һәм ҡайтарыу төҙөүселәр асыҡланмаған
иҫәп адресы, бөтә алгоритм ҡултамғалау ярҙамсылары, күп һанлы шашкалар менән ҡайтыуҙар, SM2, GOST, ML-DSA, BLS һәм серле асҡыстар менән идара итеү.
URIs, сессиялар, кадрҙар, шифрлау ярҙамсылары һәм реестр администраторы тоташтырыу
Sumeragi, узел-админ, SoraFS, UAID һәм Kaigi һуңғы нөктә ҡапламалары, унда узел был функцияларҙы аса

Үрге йүнәлештәге белешмәләр

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

Был файлдар Python өҫкө йөҙө өсөн дөрөҫлөктө сығанағы булып тора тығыҙ эш урыны ревизияһы.

Python ​

Инсталляция ​

Тиҙерәк старт ​

Бергә урынлаштырыу ​

Һалымдар һәм газ ​

Taira - Тикшерелгән уҡырға ғына шылтыратыуҙар ​

Төҙөүселәргә күрһәтмәләр ​

Домендар булдырығыҙ, ә һуңынан иҫәптәр һәм активтар теркәгеҙ ​

Минет, яндырылған һәм күсерелгән мөлкәт ​

Трансфер биләмәһе ​

Метамәғлүмәттәрҙе йыйыу һәм алып ташлау ​

Реаль донъя активтары ​

Ҡатҡандар ​

Репо һәм иҫәп-хисап буйынса күрһәтмәләр ​

JSON Ҡотҡарылыу капкаһы ​

Транзакциялар эш ағымдары ​

Һорауҙар ​

Ваҡиғалар ​

Ключтар һәм адрестар ​

Ҡытай SM Криптографияһы ​

GOST һәм "Кванттан һуңғы асҡыстар" ​

Конфигурацияланған клиенттар булдырыу ​

Кагемуша әҙерлеге ​

Абонементтар ​

Ҡатнашыу ​

Идара итеү, идара итеү ваҡыты һәм администраторҙар өҫкө йөҙө ​

Статусы, консенсус һәм селтәр телеметрияһы ​

SoraFS, UAID һәм Kaigi ярҙамсылары ​

Norito RPC һәм GPU Ярҙамсылары ​

Хәҙерге яҡтыртыу ​

Үрге йүнәлештәге белешмәләр ​

Python

Инсталляция

Тиҙерәк старт

Бергә урынлаштырыу

Һалымдар һәм газ

Taira - Тикшерелгән уҡырға ғына шылтыратыуҙар

Төҙөүселәргә күрһәтмәләр

Домендар булдырығыҙ, ә һуңынан иҫәптәр һәм активтар теркәгеҙ

Минет, яндырылған һәм күсерелгән мөлкәт

Трансфер биләмәһе

Метамәғлүмәттәрҙе йыйыу һәм алып ташлау

Реаль донъя активтары

Ҡатҡандар

Репо һәм иҫәп-хисап буйынса күрһәтмәләр

JSON Ҡотҡарылыу капкаһы

Транзакциялар эш ағымдары

Һорауҙар

Ваҡиғалар

Ключтар һәм адрестар

Ҡытай SM Криптографияһы

GOST һәм "Кванттан һуңғы асҡыстар"

Конфигурацияланған клиенттар булдырыу

Кагемуша әҙерлеге

Абонементтар

Ҡатнашыу

Идара итеү, идара итеү ваҡыты һәм администраторҙар өҫкө йөҙө

Статусы, консенсус һәм селтәр телеметрияһы

SoraFS, UAID һәм Kaigi ярҙамсылары

Norito RPC һәм GPU Ярҙамсылары

Хәҙерге яҡтыртыу

Үрге йүнәлештәге белешмәләр