Developer Guide

openssl genpkey -algorithm ed25519 -out party_key.pem      # PRIVATE key: back it up, never share it
openssl pkey -in party_key.pem -pubout -out party_pub.pem  # public key: this is what you send

echo 1220$( (printf '\x00\x00\x00\x0c'; openssl pkey -in party_key.pem -pubout -outform DER | tail -c 32) | sha256sum | cut -d' ' -f1)

BASE=https://canton.vncapital.io
CLIENT_ID=project-acme                       # yours
CLIENT_SECRET='…'                            # yours
USER_ID=11111111-2222-3333-4444-555555555555 # yours
PARTY='alice::1220…'                         # yours

# 1. get a token (valid 5 minutes)
TOKEN=$(curl -s -X POST $BASE/realms/customers/protocol/openid-connect/token \
  -d grant_type=client_credentials -d client_id=$CLIENT_ID \
  --data-urlencode "client_secret=$CLIENT_SECRET" | jq -r .access_token)

# 2. who am I, what may I do
curl -s -H "Authorization: Bearer $TOKEN" $BASE/v2/authenticated-user | jq
curl -s -H "Authorization: Bearer $TOKEN" $BASE/v2/users/$USER_ID/rights | jq

# 3. my party's contracts
END=$(curl -s -H "Authorization: Bearer $TOKEN" $BASE/v2/state/ledger-end | jq .offset)
curl -s -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -X POST $BASE/v2/state/active-contracts \
  -d "$(jq -n --arg p "$PARTY" --argjson end "$END" '{activeAtOffset:$end, verbose:false,
        filter:{filtersByParty:{($p):{cumulative:[{identifierFilter:{WildcardFilter:{value:{includeCreatedEventBlob:false}}}}]}}}}')" | jq

curl -s -X POST https://canton.vncapital.io/realms/customers/protocol/openid-connect/token \
  -d grant_type=client_credentials \
  -d client_id=project-acme \
  --data-urlencode "client_secret=$CLIENT_SECRET"

{
  "access_token": "eyJhbGciOiJSUzI1NiIs…",
  "expires_in": 300,
  "refresh_expires_in": 0,
  "token_type": "Bearer",
  "not-before-policy": 0,
  "scope": "profile email daml_ledger_api"
}

A="Authorization: Bearer $TOKEN"; J='Content-Type: application/json'

curl -s -H "$A" $BASE/v2/authenticated-user

{"user": {"id": "11111111-2222-3333-4444-555555555555", "primaryParty": "", "isDeactivated": false,
          "metadata": {"resourceVersion": "0", "annotations": {}}, "identityProviderId": "customers",
          "primaryPartyAuthentication": false}}

curl -s -H "$A" $BASE/v2/users/$USER_ID/rights

{"rights": [
  {"kind": {"CanExecuteAs": {"value": {"party": "alice::1220…"}}}},
  {"kind": {"CanReadAs":    {"value": {"party": "alice::1220…"}}}}
]}

curl -s -H "$A" $BASE/v2/state/ledger-end              # {"offset": 5554084}
curl -s -H "$A" $BASE/v2/state/connected-synchronizers

{"connectedSynchronizers": [{"synchronizerAlias": "global",
  "synchronizerId": "global-domain::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc",
  "permission": "PARTICIPANT_PERMISSION_UNSPECIFIED"}]}

curl -s -H "$A" $BASE/v2/parties/participant-id

{"participantId": "VNCapital-validator-1::122082ce1b4e75dd486b1e8749b9fb7f09a9d40af5c4686424b41da8a41d1a426c0c"}

END=$(curl -s -H "$A" $BASE/v2/state/ledger-end | jq .offset)

curl -s -H "$A" -H "$J" -X POST $BASE/v2/state/active-contracts -d "$(jq -n --arg p "$PARTY" --argjson end "$END" '{
  activeAtOffset: $end,
  verbose: true,
  filter: {filtersByParty: {($p): {cumulative: [
    {identifierFilter: {WildcardFilter: {value: {includeCreatedEventBlob: false}}}}]}}}}')"

[{
  "workflowId": "",
  "contractEntry": {"JsActiveContract": {
    "createdEvent": {
      "offset": 5553918, "nodeId": 5,
      "contractId": "00c13541edd4…",
      "templateId": "fb10433a48c2…:Splice.AmuletRules:TransferPreapproval",
      "createArgument": {"dso": "DSO::1220…", "receiver": "alice::1220…", "provider": "VNCapital-validator-1::1220…",
                         "validFrom": "2026-10-05T16:36:05.898347Z", "expiresAt": "2027-01-03T16:36:05.871903Z"},
      "createdEventBlob": "", "interfaceViews": [],
      "witnessParties": ["alice::1220…"],
      "signatories": ["DSO::1220…", "VNCapital-validator-1::1220…", "alice::1220…"],
      "observers": [],
      "createdAt": "2026-10-05T16:36:05.898347Z",
      "packageName": "splice-amulet"
    },
    "synchronizerId": "global-domain::1220…", "reassignmentCounter": 0
  }}
}]

curl -s -H "$A" -H "$J" -X POST $BASE/v2/updates/update-by-id -d "$(jq -n --arg p "$PARTY" --arg id "$UPDATE_ID" '{
  updateId: $id,
  updateFormat: {includeTransactions: {
    transactionShape: "TRANSACTION_SHAPE_LEDGER_EFFECTS",
    eventFormat: {verbose: true, filtersByParty: {($p): {cumulative: [
      {identifierFilter: {WildcardFilter: {value: {includeCreatedEventBlob: false}}}}]}}}}}}')"

{"update": {"Transaction": {"value": {
  "updateId": "12201d11b890…", "commandId": "my-command-1", "workflowId": "",
  "effectiveAt": "2026-10-05T16:36:03.516632Z",
  "offset": 5553915,
  "synchronizerId": "global-domain::1220…",
  "recordTime": "2026-10-05T16:36:03.516632Z",
  "paidTrafficCost": 3069,
  "events": [{"CreatedEvent": {"offset": 5553915, "nodeId": 0, "contractId": "00b09e4be50f…",
              "templateId": "727c0fb9711d…:Splice.Wallet.TransferPreapproval:TransferPreapprovalProposal",
              "createArgument": {"receiver": "alice::1220…", "provider": "VNCapital-validator-1::1220…", "expectedDso": "DSO::1220…"},
              "signatories": ["alice::1220…"], "observers": ["VNCapital-validator-1::1220…"],
              "createdAt": "2026-10-05T16:36:03.516632Z", "packageName": "splice-wallet"}}]
}}}}

curl -s -H "$A" -H "$J" -X POST $BASE/v2/events/events-by-contract-id -d "$(jq -n --arg p "$PARTY" --arg c "$CONTRACT_ID" '{
  contractId: $c,
  eventFormat: {verbose: false, filtersByParty: {($p): {cumulative: [
    {identifierFilter: {WildcardFilter: {value: {includeCreatedEventBlob: false}}}}]}}}}')"

curl -s -H "$A" -H "$J" -X POST $BASE/v2/updates/get-updates-page -d "$(jq -n --arg p "$PARTY" --argjson from "$LAST_SEEN_OFFSET" '{
  beginOffsetExclusive: $from,
  maxPageSize: 100,
  updateFormat: {includeTransactions: {
    transactionShape: "TRANSACTION_SHAPE_ACS_DELTA",
    eventFormat: {verbose: false, filtersByParty: {($p): {cumulative: [
      {identifierFilter: {WildcardFilter: {value: {includeCreatedEventBlob: false}}}}]}}}}}}')"

{"updates": [{"update": {"Transaction": {"value": {"updateId": "1220…", "offset": 5553915, "events": [ … ]}}}}],
 "lowestPageOffsetExclusive": 5553914,
 "highestPageOffsetInclusive": 5553918,
 "nextPageToken": "…"}

curl -s -H "$A" "$BASE/v2/interactive-submission/preferred-package-version?package-name=splice-amulet&parties=$(jq -rn --arg p "$PARTY" '$p|@uri')"

{"packagePreference": {"packageReference": {"packageId": "fb10433a48c2…", "packageName": "splice-amulet", "packageVersion": "0.1.22"},
                       "synchronizerId": "global-domain::1220…"}}

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/preferred-packages -d "$(jq -n --arg p "$PARTY" --arg s "$SYNC" '{
  packageVettingRequirements: [{packageName: "splice-amulet", parties: [$p]}], synchronizerId: $s}')"

1. prepare   POST /v2/interactive-submission/prepare          → transaction + hash        (writes nothing)
2. sign      on your machine, with the party's private key   → signature
3. execute   POST /v2/interactive-submission/executeAndWait   → committed on MainNet

SYNC='global-domain::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc'

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/prepare -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg s "$SYNC" '{
  userId: $u,
  commandId: "my-command-1",
  actAs: [$p],
  readAs: [],
  synchronizerId: $s,
  packageIdSelectionPreference: [],
  verboseHashing: false,
  commands: [ {CreateCommand: {
     templateId: "#your-package:Your.Module:YourTemplate",
     createArguments: {owner: $p, text: "hello"} }} ]
}')" > prepared.json

{"CreateCommand":   {"templateId": "#pkg:Mod:Tpl", "createArguments": { … }}}
{"ExerciseCommand": {"templateId": "#pkg:Mod:Tpl", "contractId": "00…", "choice": "ChoiceName", "choiceArgument": { … }}}

{
  "preparedTransaction": "CtUGCgMyLjESATAapgYK…",
  "preparedTransactionHash": "j/PkXEFOMREFdltLs5y3zGuCUsAoTEjnzt7+oyXCNmU=",
  "hashingSchemeVersion": "HASHING_SCHEME_VERSION_V2",
  "hashingDetails": null,
  "costEstimation": {"estimationTimestamp": "2026-10-05T16:59:09.902976Z",
                     "confirmationRequestTrafficCostEstimation": 3103,
                     "confirmationResponseTrafficCostEstimation": 0,
                     "totalTrafficCostEstimation": 3103}
}

jq -r .preparedTransactionHash prepared.json | base64 -d > hash.bin
SIG=$(openssl pkeyutl -sign -inkey party_key.pem -rawin -in hash.bin | base64 -w0)

import base64
from cryptography.hazmat.primitives import serialization
key = serialization.load_pem_private_key(open("party_key.pem", "rb").read(), password=None)
signature_b64 = base64.b64encode(key.sign(base64.b64decode(prepared["preparedTransactionHash"]))).decode()

const crypto = require("crypto"), fs = require("fs");
const key = crypto.createPrivateKey(fs.readFileSync("party_key.pem"));
const signatureB64 = crypto.sign(null, Buffer.from(prepared.preparedTransactionHash, "base64"), key).toString("base64");

FINGERPRINT=${PARTY##*::}        # the part of the party ID after the two colons

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/executeAndWait -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg fp "$FINGERPRINT" --arg sig "$SIG" \
  --arg tx "$(jq -r .preparedTransaction prepared.json)" \
  --arg hv "$(jq -r .hashingSchemeVersion prepared.json)" '{
  preparedTransaction: $tx,
  hashingSchemeVersion: $hv,
  submissionId: "my-submission-1",
  userId: $u,
  deduplicationPeriod: {Empty: {}},
  partySignatures: {signatures: [{party: $p, signatures: [{
     format: "SIGNATURE_FORMAT_CONCAT",
     signature: $sig,
     signedBy: $fp,
     signingAlgorithmSpec: "SIGNING_ALGORITHM_SPEC_ED25519"}]}]}
}')"

{"updateId": "12201d11b890b3e4eeeca9c55bbc0043e7e71ffbc1b30ac8ed097e18e4a8f232bd48", "completionOffset": 5553915}

{"code": "FAILED_TO_EXECUTE_TRANSACTION",
 "cause": "The participant failed to execute the transaction: Received 0 valid signatures from distinct keys (1 invalid), but expected at least 1 valid for alice::1220…. Transaction hash to be signed: 1220de87…. Ensure the correct transaction hash is signed with the correct key(s)."}

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/prepare -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg s "$SYNC" --arg c "$CONTRACT_ID" '{
  userId: $u, commandId: "archive-1", actAs: [$p], readAs: [], synchronizerId: $s,
  packageIdSelectionPreference: [], verboseHashing: false,
  commands: [ {ExerciseCommand: {
     templateId: "#your-package:Your.Module:YourTemplate",
     contractId: $c, choice: "Archive", choiceArgument: {} }} ]
}')" > prepared.json
# then sign (6.2) and execute (6.3)

curl -s -H "$A" -H "$J" -X POST $BASE/v2/state/active-contracts -d "$(jq -n --arg p "$PARTY" --argjson end "$END" '{
  activeAtOffset: $end, verbose: false,
  filter: {filtersByParty: {($p): {cumulative: [{identifierFilter: {InterfaceFilter: {value: {
    interfaceId: "#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding",
    includeInterfaceView: true, includeCreatedEventBlob: false}}}}]}}}}')"

{"owner": "alice::1220…",
 "instrumentId": {"admin": "DSO::1220…", "id": "Amulet"},
 "amount": "20.0000000000",
 "lock": null,
 "meta": {"values": {}}}

{"originalInstructionCid": null,
 "transfer": {"sender": "bob::1220…", "receiver": "alice::1220…", "amount": "20.0000000000",
              "instrumentId": {"admin": "DSO::1220…", "id": "Amulet"},
              "requestedAt": "2026-10-05T01:11:58.094Z", "executeBefore": "2026-10-06T01:11:58.094Z",
              "inputHoldingCids": ["00…"], "meta": {"values": {}}},
 "status": {"tag": "TransferPendingReceiverAcceptance", "value": {}},
 "meta": {"values": {}}}

CID='00e6a9d183ef…'      # contractId of the pending transfer from 7.2

curl -s -H "$A" -H "$J" -X POST "$BASE/registry/transfer-instruction/v1/$CID/choice-contexts/accept" \
  -d '{"meta": {}, "excludeDebugFields": true}' > ctx.json

{"choiceContextData": {"values": {"amulet-rules": {…}, "open-round": {…}, "external-party-config-state": {…}, "expire-lock": {…}}},
 "disclosedContracts": [{"templateId": "…", "contractId": "00…", "createdEventBlob": "…", "synchronizerId": "global-domain::1220…"}, …]}

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/prepare -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg s "$SYNC" --arg c "$CID" --slurpfile ctx ctx.json '{
  userId: $u, commandId: "accept-1", actAs: [$p], readAs: [], synchronizerId: $s,
  packageIdSelectionPreference: [], verboseHashing: false,
  commands: [ {ExerciseCommand: {
     templateId: "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferInstruction",
     contractId: $c,
     choice: "TransferInstruction_Accept",
     choiceArgument: {extraArgs: {context: $ctx[0].choiceContextData, meta: {values: {}}}} }} ],
  disclosedContracts: [ $ctx[0].disclosedContracts[] | {templateId, contractId, createdEventBlob, synchronizerId} ]
}')" > prepared.json

DSO=$(curl -s -H "$A" $BASE/api/scan/v0/dso-party-id | jq -r .dso_party_id)
# (GNU date, as on Linux)
NOW=$(date -u -d '-30 seconds' +%Y-%m-%dT%H:%M:%S.000000Z)       # must be in the past
BEFORE=$(date -u -d '+24 hours' +%Y-%m-%dT%H:%M:%S.000000Z)      # latest time the transfer may complete

jq -n --arg dso "$DSO" --arg from "$PARTY" --arg to "$RECEIVER" --arg amt "20.0000000000" \
      --arg now "$NOW" --arg before "$BEFORE" --argjson holdings '["00…holding-1…"]' '{
  expectedAdmin: $dso,
  transfer: {sender: $from, receiver: $to, amount: $amt,
             instrumentId: {admin: $dso, id: "Amulet"},
             requestedAt: $now, executeBefore: $before,
             inputHoldingCids: $holdings, meta: {values: {}}},
  extraArgs: {context: {values: {}}, meta: {values: {}}}
}' > transfer.json

curl -s -H "$A" -H "$J" -X POST $BASE/registry/transfer-instruction/v1/transfer-factory \
  -d "$(jq -n --slurpfile t transfer.json '{choiceArguments: $t[0], excludeDebugFields: true}')" > factory.json

{"factoryId": "00…",
 "transferKind": "direct",
 "choiceContext": {"choiceContextData": {"values": { … }}, "disclosedContracts": [ … ]}}

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/prepare -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg s "$SYNC" --slurpfile t transfer.json --slurpfile f factory.json '{
  userId: $u, commandId: "send-1", actAs: [$p], readAs: [], synchronizerId: $s,
  packageIdSelectionPreference: [], verboseHashing: false,
  commands: [ {ExerciseCommand: {
     templateId: "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory",
     contractId: $f[0].factoryId,
     choice: "TransferFactory_Transfer",
     choiceArgument: ($t[0] | .extraArgs.context = $f[0].choiceContext.choiceContextData) }} ],
  disclosedContracts: [ $f[0].choiceContext.disclosedContracts[] | {templateId, contractId, createdEventBlob, synchronizerId} ]
}')" > prepared.json

OPERATOR=$(curl -s -H "$A" $BASE/v2/parties/participant-id | jq -r .participantId)
DSO=$(curl -s -H "$A" $BASE/api/scan/v0/dso-party-id | jq -r .dso_party_id)

curl -s -H "$A" -H "$J" -X POST $BASE/v2/interactive-submission/prepare -d "$(jq -n \
  --arg u "$USER_ID" --arg p "$PARTY" --arg s "$SYNC" --arg op "$OPERATOR" --arg dso "$DSO" '{
  userId: $u, commandId: "preapproval-1", actAs: [$p], readAs: [], synchronizerId: $s,
  packageIdSelectionPreference: [], verboseHashing: false,
  commands: [ {CreateCommand: {
     templateId: "#splice-wallet:Splice.Wallet.TransferPreapproval:TransferPreapprovalProposal",
     createArguments: {receiver: $p, provider: $op, expectedDso: $dso} }} ]
}')" > prepared.json
# then sign (6.2) and execute (6.3)

curl -s -H "$A" "$BASE/api/scan/v0/transfer-preapprovals/by-party/$(jq -rn --arg p "$PARTY" '$p|@uri')"

{"transfer_preapproval": {"contract": {
  "template_id": "…:Splice.AmuletRules:TransferPreapproval", "contract_id": "00c13541edd4…",
  "payload": {"dso": "DSO::1220…", "receiver": "alice::1220…", "provider": "VNCapital-validator-1::1220…",
              "validFrom": "2026-10-05T16:36:05.898347Z", "expiresAt": "2027-01-03T16:36:05.871903Z"}}}}

P=$(jq -rn --arg p "$PARTY" '$p|@uri'); S=$(jq -rn --arg s "$SYNC" '$s|@uri')
curl -s -H "$A" "$BASE/api/scan/v0/domains/$S/parties/$P/participant-id"

SNAP=$(curl -s -H "$A" "$BASE/api/scan/v0/state/acs/snapshot-timestamp?before=$(date -u +%Y-%m-%dT%H:%M:%SZ)&migration_id=4" | jq -r .record_time)
curl -s -H "$A" -H "$J" -X POST $BASE/api/scan/v0/holdings/summary \
  -d "$(jq -n --arg t "$SNAP" --arg p "$PARTY" '{migration_id: 4, record_time: $t, owner_party_ids: [$p]}')"

{"record_time": "2026-10-05T15:00:00Z", "migration_id": 4, "computed_as_of_round": 116116,
 "summaries": [{"party_id": "alice::1220…", "total_unlocked_coin": "125.0000000000", "total_locked_coin": "0.0000000000",
                "total_coin_holdings": "125.0000000000", "accumulated_holding_fees_total": "0.0100000000", "…": "…"}]}

{"error": "rate limit of this project reached", "detail": null}

{"code": "INVALID_ARGUMENT", "cause": "The submitted request has invalid arguments: …",
 "correlationId": "…", "traceId": "…", "context": {}, "resources": [], "errorCategory": 8, "grpcCodeValue": 3}

#!/usr/bin/env python3
import base64, json, secrets, urllib.parse, urllib.request, urllib.error
from cryptography.hazmat.primitives import serialization

BASE          = "https://canton.vncapital.io"
CLIENT_ID     = "project-acme"                              # yours
CLIENT_SECRET = "…"                                         # yours; load it from a safe place
USER_ID       = "11111111-2222-3333-4444-555555555555"      # yours
PARTY         = "alice::1220…"                              # yours
KEY_FILE      = "party_key.pem"                             # the party's private key


def http(method, path, token=None, body=None, form=None):
    headers, data = {}, None
    if token:
        headers["Authorization"] = "Bearer " + token
    if body is not None:
        data, headers["Content-Type"] = json.dumps(body).encode(), "application/json"
    if form is not None:
        data, headers["Content-Type"] = urllib.parse.urlencode(form).encode(), "application/x-www-form-urlencoded"
    req = urllib.request.Request(BASE + path, data=data, method=method, headers=headers)
    try:
        with urllib.request.urlopen(req, timeout=120) as r:
            return r.status, json.loads(r.read() or b"{}")
    except urllib.error.HTTPError as e:
        raw = e.read()
        try:
            return e.code, json.loads(raw)
        except Exception:
            return e.code, raw.decode(errors="replace")


def get_token():
    status, r = http("POST", "/realms/customers/protocol/openid-connect/token",
                     form={"grant_type": "client_credentials", "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET})
    assert status == 200, r
    return r["access_token"]            # valid 300 seconds


def wildcard(party):
    return {"filtersByParty": {party: {"cumulative": [
        {"identifierFilter": {"WildcardFilter": {"value": {"includeCreatedEventBlob": False}}}}]}}}


def active_contracts(token):
    _, end = http("GET", "/v2/state/ledger-end", token)
    status, rows = http("POST", "/v2/state/active-contracts", token,
                        {"activeAtOffset": end["offset"], "verbose": True, "filter": wildcard(PARTY)})
    assert status == 200, rows
    return [row["contractEntry"]["JsActiveContract"]["createdEvent"] for row in rows]


def submit(token, command, disclosed=()):
    """prepare -> sign -> execute. Returns (update id, offset)."""
    _, sync = http("GET", "/v2/state/connected-synchronizers", token)
    status, prep = http("POST", "/v2/interactive-submission/prepare", token, {
        "userId": USER_ID, "commandId": "cmd-" + secrets.token_hex(8), "actAs": [PARTY], "readAs": [],
        "synchronizerId": sync["connectedSynchronizers"][0]["synchronizerId"],
        "packageIdSelectionPreference": [], "verboseHashing": False,
        "commands": [command], "disclosedContracts": list(disclosed)})
    assert status == 200, prep
    print("estimated traffic:", prep["costEstimation"]["totalTrafficCostEstimation"], "bytes")

    key = serialization.load_pem_private_key(open(KEY_FILE, "rb").read(), password=None)
    signature = key.sign(base64.b64decode(prep["preparedTransactionHash"]))      # raw 32 bytes, Ed25519

    status, done = http("POST", "/v2/interactive-submission/executeAndWait", token, {
        "preparedTransaction": prep["preparedTransaction"],
        "hashingSchemeVersion": prep["hashingSchemeVersion"],
        "submissionId": "sub-" + secrets.token_hex(8), "userId": USER_ID,
        "deduplicationPeriod": {"Empty": {}},
        "partySignatures": {"signatures": [{"party": PARTY, "signatures": [{
            "format": "SIGNATURE_FORMAT_CONCAT", "signature": base64.b64encode(signature).decode(),
            "signedBy": PARTY.split("::")[1], "signingAlgorithmSpec": "SIGNING_ALGORITHM_SPEC_ED25519"}]}]}})
    assert status == 200, done
    return done["updateId"], done["completionOffset"]


if __name__ == "__main__":
    token = get_token()
    for c in active_contracts(token):
        print(c["contractId"][:16], c["templateId"].split(":", 1)[1])

    # One command per transaction. Replace with a template of a package installed for you.
    update_id, offset = submit(token, {"CreateCommand": {
        "templateId": "#your-package:Your.Module:YourTemplate",
        "createArguments": {"owner": PARTY, "text": "hello"}}})
    print("committed:", update_id, "at offset", offset)