Python

Python SDK במרחב העבודה העליון הוא iroha-python. השחרור הראשון Iroha 3 מטרה על פני השטח הנוכחי Torii ו Norito. חישוב את הגרסה של החבילה או תיקון המקור המשמש על ידי האינטגרציה שלך כך ש SDK והנקודה יישארו על אותו תיקון פורמט כבלים.

דוגמאות קריאה בלבד הבאות נבדקו נגד ציבורית Taira ב https://taira.sora.org. דוגמאיות מוטציות הן טמבלטים של עסקאות: הם דורשים סמכות אמיתית Taira, מפתח פרטי, מטא נתונים על גז וכל סימנים למפעיל הנדרשים על ידי מסלול היעד לפני שהם יכולים להגיש.

השתמשו בדוגמאות בסדר זה:

שלב	לרוץ נגד הציבור Taira?	מה אתה צריך?
שיחות לקוחות קריאה בלבד.	כן.	Python חבילה ועוד גישה לרשת
יצרנים מקומיים של חתימות והוראות	אין שיחת רשת עד `submit()`	ההרחבה המקומית והחומר המרכזי שלך.
העסקים המוטלים וקריאות שירות	רק עם חשבון משומך שלך.	חשבון הסוכנות, מפתח פרטי, שרשרת ID, מטא נתונים על דמי הדמיה, סולן נכסי הדמיה והצבעות של הנתיב
חיבור קודקים מסגרת, קריפטו, ו GPU עוזרים	מקומי בלבד.	הרחבה המקומית; GPU עוזרים צריכים גם backend יכולת CUDA

להתקין

השם של הנתונים המטאטאוניים של החבילה הוא iroha-python. אל תחשבו כי התקנת PyPI לא מחוברת מתאימה לרשת Taira חיה. תקין גלגל או קישור מקור שנבנה מאותו תיקון מעלה מטרות האינטגרציה שלך:

bash

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

אם הפרויקט שלך צורב את חלל העבודה העליון באופן ישיר, תקין את התלות Python ובנה את ההרחבה המקומית לפני שתפעיל דוגמאות שמשתמשות Instruction, TransactionDraft, חתימה, קריפטו, SoraFS עוזרים מקומיים, GPU עוזרים, או קודקים של מסגרת Connect. השתמש בפקודה "הבנה" מ- 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` מיועד למכשירים גנזיס/צליחת אקדח
לא רשום.	`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`
הסכום/הסירוב, SetParameter, רישום, מנהג, שיפור, ומוזוגים פחות נפוצים של רישום/לא רישום	`Instruction.from_json` או `TransactionBuilder.add_instruction_json` עם קאנוניקה `InstructionBox` JSON

עבור תשלומים קבועים בסגנון מאבטח, ראה מאבטח נכסים מקומיים . Python חושף כיום עוזרים מעמד ראשון למנעולים של נכסים גנטיים; השוק ועוזרי מאבטח אנונימיים אינם עדיין שיטות מעמד ראשון Python.

להגדיר דומיינים, ואז להירשם חשבונות ומשכרים

יצירת תחום דומיין רגיל עוברת דרך מתכנן התכונות המפורסמת כך שהכרזת SNS, יכולות הבעלים, אבטחת הציטוט, ומצב התחום בודקים יחד. ליצור כוונה ללא סוד AliasSetupPlanRequestV1 עם SDK או שירות האינטרנט שלך, ולאחר מכן להשתמש iroha app alias setup plan ו iroha app alias setup apply. לא להגיש Instruction.register_domain מטראפקציה של יישום; הבניין הזה נשאר למכשירים גנז / סטראפ.

לאחר שתוכנית הקמת הדומיין מתחייבת, רשום אובייקטים בבעלות הדומיין. ברשת משותפת כגון 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 הופכת לחשבון היעד המקובל.

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 על הקבוצה הקיימת. העברת חלקית והפליגה יוצרות קבוצות ילדים שנוצרו.

תפעילים

השתמשו בעוזרי הרישום של ההצלה כאשר המפעיל הוא רצף הוראות אחר:

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

שיחות מא inventory של Trigger קוראים או בודקים רק רישומים של trigger. הרישום, ביצוע, שינויים חוזרים ולאירוך הם מבצעים מוטתיים.

הוראות לאישור וההסדר

רופאים ועוזרי הסדר דו-צדדיים מוסיפים סוגי הוראות ספציפיות לתחום ללא מטענים מועילים של 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 שם האירוע, תעודת זהות, נתיב ניסיון מחדש, וטעינה חומרית. זוג זרמים עם 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) חתימות לאחר קוואנטום. האובייקט זהה של זוג מפתחות מטפל בחתימה, בדיקת, ויצוא מולטי-האש:

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)

שער 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 כאשר היישום שלך קורא את ההגדרות של הערך מתוך קובץ, אך עדיין זקוק ל-overrides הספציפיים לסביבה או למבחן:

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 יכול לבקש את מסלול הכנות הנוכחי של JSON באמצעות העוזר הדרישה הגנטי שלו Torii:

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, ולאחר מכן הגיש ונסקר אותם באמצעות לקוח קגמשה תומך 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 עוזרים להחזיר None כאשר ההסגר לא זמין, כך יישומים יכולים לחזור ליישום skalar:

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, node-admin, 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 עוזרים

הכיסוי הנוכחי

ראשי תיקון מקדימה