Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Guide de l'utilisateur sur le calcul multipartite

Ce guide décrit les parcours utilisateur de l'API Multi-party Compute pour gérer les clés distribuées, les utilisateurs, les équipes et les règles. Il est destiné aux clients de la version preview qui découvrent les principaux parcours utilisateur.

Présentation

L'API MPC gère le cycle de vie des instances, des équipes, des utilisateurs, des trousseaux de clés, des clés distribuées et des cérémonies de signature de seuil, avec une gouvernance cryptographique intégrée appliquée sur trois couches de règles :

Règles d'administration (quorums de rôles) : les administrateurs intègrent les utilisateurs et les équipes, et un quorum d'administrateurs (EnableUserRole et ApproveRoleChange) est requis pour accorder ou révoquer les rôles Administrateur et Auteur de règles. L'attribution du rôle Signataire prend effet immédiatement à partir d'un seul administrateur, car le rôle Signataire seul n'accorde pas l'accès aux clés existantes. Un Signataire ne reçoit des parts de clé que lorsqu'il est inclus dans la KeyPolicy d'un KeyRing lors de la génération de la clé.
Règles de clé (KeyRing.keyPolicy) : les administrateurs définissent la KeyPolicy d'un KeyRing lors de la création du KeyRing, en spécifiant quels Signers (Signer, regroupés en Teams) détiennent des parts de clé et les approbations de signataires K-of-N (CreateTransaction et RecordSignerDecision) requises pour autoriser une signature.
Règles de transaction (TransactionPolicy et KeyList) : un quorum d'auteurs de règles (POLICY_AUTHOR) propose, approuve ou désactive les règles permit et forbid Cedar (TransactionPolicy) et les listes d'autorisation d'adresses KeyList. Chaque requête CreateTransaction est évaluée par rapport aux règles de transaction actives (PERMIT ou DENY) avant la signature.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

A Google Cloud Project. Consultez Créer des projets pour en créer un.
Si vous n'utilisez pas Cloud Shell, la CLI gcloud doit être installée et authentifiée.
Les API requises doivent être activées, si ce n'est pas déjà fait. Vous en avez besoin de deux : l'API MPC utilisée dans ce guide et Cloud Key Management Service si vous l'utilisez pour générer et signer des clés d'autorisation.
```
  gcloud services enable mpc.googleapis.com cloudkms.googleapis.com
```
Pour afficher les API activées :
```
  gcloud services list --enabled
```
Python 3.9 ou version ultérieure et les bibliothèques d'aide du tutoriel sont installés :
```
  pip install embit eth-account eth-utils requests
```
(Facultatif) Si votre organisation s'authentifie à l'aide d'un fournisseur d'identité externe (comme Okta ou Microsoft Entra ID) sans compte Google, consultez Configurer la fédération des identités des employés (BYOID) pour configurer les Identifiants par défaut de l'application (ADC) avec votre identité fédérée.

Configuration

Mettez à jour les variables suivantes pour renseigner les commandes de ce guide.

Configuration requise

Vous devez personnaliser ces paramètres. Le guide ne fonctionnera pas avec les valeurs d'espace réservé.

Remarque Simulation solo ou simulation multi-utilisateur : dans un environnement réaliste, ce système repose sur une séparation stricte des tâches entre plusieurs personas (administrateurs, auteurs de règles et signataires), chacun disposant d'un compte principal, d'une clé d'autorisation cryptographique et d'autorisations IAM distincts. Étant donné que l'API applique la règle selon laquelle chaque User est lié à un seul compte principal et ne peut pas approuver lui-même les actions de rôle ou de quorum, vous devez disposer de plusieurs comptes utilisateur pour suivre ce guide de bout en bout. Nous prévoyons d'ajouter la compatibilité pour simplifier les tests mono-utilisateur dans une prochaine version. Chaque compte principal User peut être une adresse e-mail Google Cloud ou un compte principal de la fédération des identités des employés (BYOID). Ce guide utilise des exemples d'adresses e-mail Google Cloud (comme alice@example.com).

Paramètre	Valeur	Description
ID du projet	`my-project`	ID du projet client pour votre instance MPC.
ID d'instance	`my-mpc-instance`	ID de votre instance MPC (`[a-z]([a-z0-9-]{0,61}[a-z0-9])?`).
Emplacement	`us-central1`	Emplacement du déploiement (par exemple, `us-central1`).
Admin 1 Principal	`admin-1@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID du premier utilisateur `ADMIN` de l'instance.
Administrateur 2	`admin-2@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID du deuxième utilisateur `ADMIN` de l'instance.
Signer 1 Principal	`alice@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID du signataire 1 (Alice).
Principal du signataire 2	`bob@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID du signataire 2 (Bob).
Signataire 3 principal	`charlie@example.com`	Adresse e-mailGoogle Cloud ou compte principal BYOID du signataire 3 (Charlie).
Policy Author 1 Principal	`dave@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID de l'auteur de la stratégie 1 (Dave).
Policy Author 2 Principal	`eve@example.com`	Google Cloud Adresse e-mail ou compte principal BYOID de l'auteur de la stratégie 2 (Eve).

Authentifiez chaque compte une fois dans votre session de terminal afin que gcloud auth print-access-token "<principal>" puisse récupérer les jetons de n'importe quel persona sans changer de compte en cours de tutoriel (ADMIN_1_PRINCIPAL est authentifié en dernier, de sorte qu'il reste le compte CLI gcloud actif pour les commandes IAM et Cloud KMS) :

for PRINCIPAL in \
  "admin-2@example.com" \
  "alice@example.com" \
  "bob@example.com" \
  "charlie@example.com" \
  "dave@example.com" \
  "eve@example.com" \
  "admin-1@example.com"; do
  gcloud auth login "$PRINCIPAL"
done

Libellés de ressource du tutoriel

Il s'agit d'identifiants locaux pour les clés d'autorisation créées à l'aide de Cloud KMS au cours de ce tutoriel. Les valeurs par défaut sont valides et peuvent être conservées pour minimiser les difficultés de configuration. Notez que les ID des ressources Team, User, TransactionPolicy, KeyRing, Key, KeyList et Transaction sont générés par le serveur et capturés dans des variables d'interface système (TEAM_NAME, SIGNER_1_NAME, POLICY_NAME, KEY_RING_NAME, KEY_NAME, KEY_LIST_NAME, TRANSACTION_NAME) lors de la création de chaque ressource.

Paramètre	Valeur	Description
ID du trousseau de clés Cloud KMS	`mpc-assent-keys`	Porte-clés Cloud Key Management Service pour les clés d'autorisation externes stockées dans Cloud KMS.
ID de l'administrateur Cloud KMS 1	`admin-1`	Libellé de la clé d'autorisation MPC Admin 1.
ID de l'administrateur Cloud KMS 2	`admin-2`	Libellé de la clé d'autorisation MPC Admin 2.
ID du signataire 1 Cloud KMS	`signer-alice`	Libellé de la clé d'autorisation du signataire MPC 1.
ID du signataire Cloud KMS 2	`signer-bob`	Libellé de la clé d'autorisation MPC Signer 2.
ID du signataire Cloud KMS 3	`signer-charlie`	Libellé de la clé d'autorisation du signataire MPC 3.
ID de l'auteur de la stratégie Cloud KMS 1	`author-dave`	Libellé de la clé d'autorisation de l'auteur de la règle 1.
ID de l'auteur de règles Cloud KMS 2	`author-eve`	Libellé de la clé d'autorisation de l'auteur de la règle 2.

Étape 1 : Créez une instance MPC

Un Instance MPC représente votre environnement MPC dédié et isolé. Pour créer et administrer une instance, vous devez disposer du rôle IAM Administrateur de calcul multipartite (roles/mpc.admin) sur votre projet. Vous créez et inspectez le Instance en tant qu'administrateur à l'aide de MPCInstanceService sur le point de terminaison du plan de contrôle (https://mpc.googleapis.com), et vous envoyez toutes les requêtes de ressources ultérieures à l'URL du plan de données dédiée de l'instance (INSTANCE_URL).

A. Créer l'instance

Tout d'abord, assurez-vous que vos comptes principaux d'administrateur (admin-1@example.com et admin-2@example.com) disposent de roles/mpc.admin sur le projet, puis appelez instances.create (CreateInstance) en tant qu'administrateur 1 pour provisionner votre instance MPC :

curl

grant_iam_role() {
  local principal=$1
  local iam_role=$2
  local member="user:${principal}"

  # BYOID principals already start with "principal://"
  if [[ "$principal" == principal://* ]]; then
    member="${principal}"
  fi

  echo "Granting ${iam_role} to ${member}..."
  gcloud projects add-iam-policy-binding "my-project" \
    --member="${member}" \
    --role="${iam_role}" \
    --condition=None > /dev/null
}

for ADMIN_PRINCIPAL in "admin-1@example.com" "admin-2@example.com"; do
  grant_iam_role "$ADMIN_PRINCIPAL" "roles/mpc.admin"
done

export INSTANCE_NAME="projects/my-project/locations/us-central1/instances/my-mpc-instance"

# Check existence
if curl -s -f -o /dev/null -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "https://mpc.googleapis.com/v1beta/${INSTANCE_NAME}"; then
  echo "Instance 'my-mpc-instance' already exists. Skipping creation."
else
  echo "Instance 'my-mpc-instance' not found. Creating..."
  curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d '{
      "displayName": "Tutorial MPC Instance"
    }' \
    "https://mpc.googleapis.com/v1beta/projects/my-project/locations/us-central1/instances?instanceId=my-mpc-instance" | jq
fi

Cette opération renvoie une opération de longue durée (LRO). Vous devez attendre que l'instance state passe à l'état ACTIVE avant d'appeler l'URL de son plan de données.

🕵️‍♂️ Vérifier l'état de l'instance (interrogation)

Interrogez l'état de l'instance jusqu'à ce que state devienne ACTIVE, puis enregistrez son champ url dans INSTANCE_URL :

curl

INSTANCE_INFO=$(curl -s -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "https://mpc.googleapis.com/v1beta/${INSTANCE_NAME}")

echo "$INSTANCE_INFO" | jq
export INSTANCE_URL=$(echo "$INSTANCE_INFO" | jq -r '.url')
echo "Instance Data Plane URL: $INSTANCE_URL"

Étape 2 : Générer des clés d'autorisation

Pour utiliser l'API MPC, vous devez générer des paires de clés pour les rôles distincts suivants. Notez qu'il s'agit de clés d'autorisation cryptographiques externes (User.authorizationKey), ce qui signifie que vous les générez et les conservez en dehors de l'instance MPC. Elles sont donc distinctes des parts de clé MPC générées lors de la création de la clé :

Administrateurs : autorisent les modifications des rôles utilisateur ADMIN et POLICY_AUTHOR, et créent des Key.
Auteurs de règles : autoriser les règles de gouvernance (TransactionPolicy).
Signataires : fournissent une autorisation (AUTHORIZE ou DENY) pour les transactions.

Générez les clés d'autorisation cryptographiques secp256k1 pour vos signataires, vos auteurs de règles et vos administrateurs. Ces commandes sont idempotentes.

Cloud KMS

Nous vous recommandons de gérer les clés d'autorisation dans Cloud Key Management Service. Assurez-vous que votre identité dispose des autorisations nécessaires pour créer des trousseaux de clés, créer des clés, signer et afficher les vérificateurs de clés publiques (tels que roles/cloudkms.admin et roles/cloudkms.signerVerifier). Assurez-vous d'avoir créé un KeyRing, puis générez une clé secp256k1 pour chaque signataire, auteur de règle et administrateur.

provision_keyring() {
  if gcloud kms keyrings describe "mpc-assent-keys" --location="us-central1" > /dev/null 2>&1; then
    echo "KeyRing 'mpc-assent-keys' already exists."
  else
    echo "KeyRing 'mpc-assent-keys' not found. Creating it..."
    gcloud kms keyrings create "mpc-assent-keys" --location="us-central1"
  fi
}

provision_kms_key() {
  local id=$1
  if gcloud kms keys describe "${id}-key" --keyring="mpc-assent-keys" --location="us-central1" > /dev/null 2>&1; then
    echo "KMS key '${id}-key' already exists."
  else
    echo "KMS key '${id}-key' not found. Creating it..."
    gcloud kms keys create "${id}-key" \
      --keyring="mpc-assent-keys" \
      --location="us-central1" \
      --purpose=asymmetric-signing \
      --default-algorithm=ec-sign-secp256k1-sha256 \
      --protection-level=hsm
  fi

  gcloud kms keys versions get-public-key 1 \
    --key="${id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --output-file="${id}_pub.pem"

  echo "Retrieved public key from KMS and saved to ${id}_pub.pem:"
  cat "${id}_pub.pem"
}

# Run Setup
provision_keyring

# Generate Keys for Signers, Policy Authors, and Admins
for ID in \
  signer-alice \
  signer-bob \
  signer-charlie \
  author-dave \
  author-eve \
  admin-1 \
  admin-2; do
  echo "Generating KMS key for $ID..."
  provision_kms_key "$ID"
done

OpenSSL

Vous pouvez utiliser OpenSSL standard pour générer des clés secp256k1 pour chaque signataire, auteur de règles et administrateur.

provision_openssl_key() {
  local id=$1
  if [[ ! -f "${id}_priv.pem" ]]; then
    openssl ecparam -name secp256k1 -genkey -noout -out "${id}_priv.pem"
    openssl ec -in "${id}_priv.pem" -pubout -out "${id}_pub.pem"
    echo "Wrote private key to ${id}_priv.pem and public key to ${id}_pub.pem:"
    cat "${id}_pub.pem"
  else
    echo "Private key file '${id}_priv.pem' already exists. Skipping OpenSSL generation."
    echo "Using existing public key from '${id}_pub.pem':"
    cat "${id}_pub.pem"
  fi
}

for ID in \
  signer-alice \
  signer-bob \
  signer-charlie \
  author-dave \
  author-eve \
  admin-1 \
  admin-2; do
  echo "Generating OpenSSL key for $ID..."
  provision_openssl_key "$ID"
done

Étape 3 : Enregistrez les équipes et les utilisateurs

Avant qu'une entité puisse participer à la signature de transactions (en tant que SIGNER) ou à la création de règles (en tant que POLICY_AUTHOR), elle doit disposer d'autorisations IAM sur le projet et être enregistrée en tant que User au niveau de l'application dans l'instance (consultez Sécurité et autorisation pour savoir comment les rôles IAM et les rôles User fonctionnent ensemble).

L'enregistrement nécessite une coordination hors bande entre l'administrateur et l'utilisateur :

L'entité (signataire ou auteur de la règle) génère sa paire de clés localement et transfère sa clé publique à l'administrateur de manière sécurisée.
L'administrateur accorde au compte principal de l'utilisateur le rôle IAM approprié sur le projet (roles/mpc.editor pour les signataires et les auteurs de règles ; roles/mpc.admin pour les administrateurs) et appelle l'API MPC pour enregistrer les principal et authorizationKey de l'utilisateur.

A. Créer une équipe de signataires

Chaque User avec le rôle SIGNER doit appartenir à un Team, et tous les autres User avec d'autres rôles ne peuvent pas appartenir à un Team. En tant qu'Administrateur 1 (admin-1@example.com), créez un Team (CreateTeam) "Treasury Signers" pour stocker vos trois signataires et capturer sa ressource name générée par le serveur :

curl

TEAM_RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d '{
    "displayName": "Treasury Signers",
  }' \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/teams?requestId=11111111-1111-4111-8111-111111111101")

echo "$TEAM_RESPONSE" | jq
export TEAM_NAME=$(echo "$TEAM_RESPONSE" | jq -r '.name')
echo "Created Team: $TEAM_NAME"

B. Attribuer des rôles IAM et enregistrer des signataires et des auteurs de règles

Chaque utilisateur doit disposer d'un rôle IAM au niveau du projet (roles/mpc.editor pour les signataires et les auteurs de règles, et roles/mpc.admin pour les administrateurs) pour appeler l'API MPC, ainsi que d'une ressource User au niveau de l'application dans l'instance. Lorsque vous appelez users.create (CreateUser), le champ roles ne peut être que vide ou défini sur ["SIGNER"] :

Signataires : rôle roles/mpc.editor accordé dans IAM et créé avec roles: ["SIGNER"] et team: "$TEAM_NAME". Le rôle SIGNER devient immédiatement ACTIVE sans nécessiter l'approbation du quorum d'administrateurs, car le rôle SIGNER seul ne donne pas accès aux clés existantes. Un signataire ne reçoit des parts de clé que s'il est inclus dans le KeyPolicy d'un KeyRing lors de la génération de la clé.
Auteurs de règles : ils disposent de l'autorisation roles/mpc.editor dans IAM et sont créés sans rôles initiaux ni team, puis se voient attribuer le rôle POLICY_AUTHOR à l'étape 3.C à l'aide de l'approbation du quorum d'administrateurs (car POLICY_AUTHOR et ADMIN disposent d'une autorité de gouvernance à l'échelle de l'instance).

curl

provision_user() {
  local id=$1
  local display_name=$2
  local principal=$3
  local request_id=$4
  local team=$5
  local pubkey_b64
  local signer_fields=""

  # 1. Grant project-level IAM permission (roles/mpc.editor) to the User's principal
  grant_iam_role "$principal" "roles/mpc.editor" >&2

  # 2. Read the public key from the file generated in Step 2 (Base64-encoded PEM/DER bytes)
  pubkey_b64=$(openssl base64 -A -in "${id}_pub.pem")

  if [[ -n "$team" ]]; then
    signer_fields=", \"roles\": [\"SIGNER\"], \"team\": \"${team}\""
  fi

  # 3. Register the application-level User in the MPC instance as Admin 1
  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"displayName\": \"${display_name}\",
      \"principal\": \"${principal}\",
      \"authorizationKey\": {
        \"publicKey\": \"${pubkey_b64}\",
        \"algorithm\": \"PUBLIC_KEY_SIGNATURE_ALGORITHM_ECDSA_SECP256K1\"
      }${signer_fields}
    }" \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/users?requestId=${request_id}"
}

echo "Registering Signers..."
export SIGNER_1_NAME=$(provision_user "signer-alice" "Signer Alice" "alice@example.com" "11111111-1111-4111-8111-111111111001" "${TEAM_NAME}" | tee /dev/stderr | jq -r '.name')
export SIGNER_2_NAME=$(provision_user "signer-bob" "Signer Bob" "bob@example.com" "11111111-1111-4111-8111-111111111002" "${TEAM_NAME}" | tee /dev/stderr | jq -r '.name')
export SIGNER_3_NAME=$(provision_user "signer-charlie" "Signer Charlie" "charlie@example.com" "11111111-1111-4111-8111-111111111003" "${TEAM_NAME}" | tee /dev/stderr | jq -r '.name')

echo "Registering Policy Authors..."
export POLICY_AUTHOR_1_NAME=$(provision_user "author-dave" "Author Dave" "dave@example.com" "11111111-1111-4111-8111-111111111004" | tee /dev/stderr | jq -r '.name')
export POLICY_AUTHOR_2_NAME=$(provision_user "author-eve" "Author Eve" "eve@example.com" "11111111-1111-4111-8111-111111111005" | tee /dev/stderr | jq -r '.name')

C. Attribuer le rôle d'auteur de règles (approbation par quorum d'administrateurs)

L'activation ou la désactivation du rôle POLICY_AUTHOR ou ADMIN sur un User nécessite un quorum d'administrateurs :

L'administrateur 1 appelle users.enableRole (EnableUserRole), ce qui déplace le rôle vers PENDING_ACTIVE et enregistre la signature de l'administrateur 1 en tant que première approbation.
L'administrateur 2 appelle users.approveRoleChange (ApproveRoleChange) avec sa signature, ce qui fait passer le rôle à ACTIVE.

Cloud KMS

1. Demander POLICY_AUTHOR en tant qu'Administrateur 1 (EnableUserRole)

sign_role_change() {
  local admin_id=$1
  local target_id=$2
  local principal=$3
  python3 -c 'import sys; inst, prin, pub = sys.argv[1], sys.argv[2], open(sys.argv[3], "rb").read(); v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("role_payload.bin", "wb").write(f(1, inst.encode()) + f(2, prin.encode()) + f(3, f(1, pub) + b"\x10\x01") + f(4, b"\x08\x02\x10\x01\x18\x01"))' "${INSTANCE_NAME}" "${principal}" "${target_id}_pub.pem"
  gcloud kms asymmetric-sign \
    --version=1 \
    --key="${admin_id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --digest-algorithm=sha256 \
    --input-file=role_payload.bin \
    --signature-file=role_sig.bin > /dev/null
  openssl base64 -A -in role_sig.bin
}

enable_policy_author() {
  local target_user=$1
  local target_id=$2
  local target_principal=$3

  echo "Admin 1 requesting POLICY_AUTHOR for ${target_user}..."
  local admin_1_sig=$(sign_role_change "admin-1" "${target_id}" "${target_principal}")
  local signed_payload_b64=$(openssl base64 -A -in role_payload.bin)

  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"role\": \"POLICY_AUTHOR\",
      \"authorizationInfo\": {
        \"signature\": \"${admin_1_sig}\",
        \"signedPayload\": \"${signed_payload_b64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${target_user}:enableRole" | jq
}

enable_policy_author "${POLICY_AUTHOR_1_NAME}" "author-dave" "dave@example.com"
enable_policy_author "${POLICY_AUTHOR_2_NAME}" "author-eve" "eve@example.com"

2. Approuver POLICY_AUTHOR en tant qu'Administrateur 2 (ApproveRoleChange)

approve_policy_author() {
  local target_user=$1
  local target_id=$2
  local target_principal=$3

  echo "Admin 2 approving POLICY_AUTHOR for ${target_user}..."
  local admin_2_sig=$(sign_role_change "admin-2" "${target_id}" "${target_principal}")
  local signed_payload_b64=$(openssl base64 -A -in role_payload.bin)

  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-2@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"authorizationInfo\": {
        \"signature\": \"${admin_2_sig}\",
        \"signedPayload\": \"${signed_payload_b64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${target_user}:approveRoleChange" | jq
}

approve_policy_author "${POLICY_AUTHOR_1_NAME}" "author-dave" "dave@example.com"
approve_policy_author "${POLICY_AUTHOR_2_NAME}" "author-eve" "eve@example.com"

OpenSSL

1. Demander POLICY_AUTHOR en tant qu'Administrateur 1 (EnableUserRole)

sign_role_change() {
  local admin_id=$1
  local target_id=$2
  local principal=$3
  python3 -c 'import sys; inst, prin, pub = sys.argv[1], sys.argv[2], open(sys.argv[3], "rb").read(); v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("role_payload.bin", "wb").write(f(1, inst.encode()) + f(2, prin.encode()) + f(3, f(1, pub) + b"\x10\x01") + f(4, b"\x08\x02\x10\x01\x18\x01"))' "${INSTANCE_NAME}" "${principal}" "${target_id}_pub.pem"
  openssl dgst -sha256 -sign "${admin_id}_priv.pem" -out role_sig.bin role_payload.bin
  openssl base64 -A -in role_sig.bin
}

enable_policy_author() {
  local target_user=$1
  local target_id=$2
  local target_principal=$3

  echo "Admin 1 requesting POLICY_AUTHOR for ${target_user}..."
  local admin_1_sig=$(sign_role_change "admin-1" "${target_id}" "${target_principal}")
  local signed_payload_b64=$(openssl base64 -A -in role_payload.bin)

  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"role\": \"POLICY_AUTHOR\",
      \"authorizationInfo\": {
        \"signature\": \"${admin_1_sig}\",
        \"signedPayload\": \"${signed_payload_b64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${target_user}:enableRole" | jq
}

enable_policy_author "${POLICY_AUTHOR_1_NAME}" "author-dave" "dave@example.com"
enable_policy_author "${POLICY_AUTHOR_2_NAME}" "author-eve" "eve@example.com"

2. Approuver POLICY_AUTHOR en tant qu'Administrateur 2 (ApproveRoleChange)

approve_policy_author() {
  local target_user=$1
  local target_id=$2
  local target_principal=$3

  echo "Admin 2 approving POLICY_AUTHOR for ${target_user}..."
  local admin_2_sig=$(sign_role_change "admin-2" "${target_id}" "${target_principal}")
  local signed_payload_b64=$(openssl base64 -A -in role_payload.bin)

  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-2@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"authorizationInfo\": {
        \"signature\": \"${admin_2_sig}\",
        \"signedPayload\": \"${signed_payload_b64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${target_user}:approveRoleChange" | jq
}

approve_policy_author "${POLICY_AUTHOR_1_NAME}" "author-dave" "dave@example.com"
approve_policy_author "${POLICY_AUTHOR_2_NAME}" "author-eve" "eve@example.com"

Étape 4 : Configurer les règles de transaction

Configurez des règles de transaction en créant et en approuvant un TransactionPolicy (et éventuellement un KeyList).

A. Créer une règle (PENDING_ACTIVE)

Créez une règle de stratégie Cedar décrivant les transactions autorisées. Bien que vous puissiez configurer de nombreuses règles pour régir différents scénarios, ce guide explique comment configurer une règle pour les transactions Ethereum ou Bitcoin. Par défaut, l'évaluation de la règle de transaction est Fail-Fast (bloquer par défaut). Si aucune règle permit active ne correspond à une transaction, la décision d'évaluation de la règle est DENY. Pour en savoir plus sur les attributs Cedar, consultez Écrire des règles de stratégie de transaction.

Ethereum, KMS

Cette règle autorise les transferts Ethereum de plus petite taille (<= 2 ETH, représentés par 2,000,000,000 en unités de 10^-9 ETH / Gwei) vers une adresse de destinataire spécifique (0x1111111111111111111111111111111111111111).

permit (principal, action, resource)
when {
  context.schema == "ETHEREUM_TX_V2" &&
  context.secondary_key == "0x1111111111111111111111111111111111111111" &&
  context has amount_token_scaled &&
  context.amount_token_scaled <= 2000000000
};

sign_policy() {
  local author_id=$1
  local resource_type=$2
  local resource_name=$3
  local action=$4
  local cedar_doc=$5
  python3 -c 'import sys; rt, rn, act, doc = sys.argv[1:]; v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("policy_payload.bin", "wb").write(f(1 if rt == "instance" else 2, rn.encode()) + bytes([24, 1 if act == "ACTIVATE" else 2]) + f(4, f(1, doc.encode())))' "${resource_type}" "${resource_name}" "${action}" "${cedar_doc}"
  gcloud kms asymmetric-sign \
    --version=1 \
    --key="${author_id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --digest-algorithm=sha256 \
    --input-file=policy_payload.bin \
    --signature-file=policy_sig.bin > /dev/null
  openssl base64 -A -in policy_sig.bin
}

export CEDAR_RULE='permit (principal, action, resource) when { context.schema == "ETHEREUM_TX_V2" && context.secondary_key == "0x1111111111111111111111111111111111111111" && context has amount_token_scaled && context.amount_token_scaled <= 2000000000 };'

# Sign as Policy Author 1
QUORUM_SIGNATURE=$(sign_policy "author-dave" "instance" "${INSTANCE_NAME}" "ACTIVATE" "${CEDAR_RULE}")
POLICY_PAYLOAD_B64=$(openssl base64 -A -in policy_payload.bin)

POLICY_RESPONSE=$(jq -n \
  --arg rule "$CEDAR_RULE" \
  --arg sig "$QUORUM_SIGNATURE" \
  --arg payload "$POLICY_PAYLOAD_B64" \
  '{
    transactionPolicy: {
      displayName: "Ethereum Transfer Permit Policy",
      rule: {cedarDocument: $rule}
    },
    authorizationInfo: {
      signature: $sig,
      signedPayload: $payload
    },
    requestId: "11111111-1111-4111-8111-111111111201"
  }' \
| curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "dave@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d @- \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/transactionPolicies")

echo "$POLICY_RESPONSE" | jq
export POLICY_NAME=$(echo "$POLICY_RESPONSE" | jq -r '.name')

Ethereum, OpenSSL

permit (principal, action, resource)
when {
  context.schema == "ETHEREUM_TX_V2" &&
  context.secondary_key == "0x1111111111111111111111111111111111111111" &&
  context has amount_token_scaled &&
  context.amount_token_scaled <= 2000000000
};

sign_policy() {
  local author_id=$1
  local resource_type=$2
  local resource_name=$3
  local action=$4
  local cedar_doc=$5
  python3 -c 'import sys; rt, rn, act, doc = sys.argv[1:]; v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("policy_payload.bin", "wb").write(f(1 if rt == "instance" else 2, rn.encode()) + bytes([24, 1 if act == "ACTIVATE" else 2]) + f(4, f(1, doc.encode())))' "${resource_type}" "${resource_name}" "${action}" "${cedar_doc}"
  openssl dgst -sha256 -sign "${author_id}_priv.pem" -out policy_sig.bin policy_payload.bin
  openssl base64 -A -in policy_sig.bin
}

export CEDAR_RULE='permit (principal, action, resource) when { context.schema == "ETHEREUM_TX_V2" && context.secondary_key == "0x1111111111111111111111111111111111111111" && context has amount_token_scaled && context.amount_token_scaled <= 2000000000 };'

# Sign as Policy Author 1
QUORUM_SIGNATURE=$(sign_policy "author-dave" "instance" "${INSTANCE_NAME}" "ACTIVATE" "${CEDAR_RULE}")
POLICY_PAYLOAD_B64=$(openssl base64 -A -in policy_payload.bin)

POLICY_RESPONSE=$(jq -n \
  --arg rule "$CEDAR_RULE" \
  --arg sig "$QUORUM_SIGNATURE" \
  --arg payload "$POLICY_PAYLOAD_B64" \
  '{
    transactionPolicy: {
      displayName: "Ethereum Transfer Permit Policy",
      rule: {cedarDocument: $rule}
    },
    authorizationInfo: {
      signature: $sig,
      signedPayload: $payload
    },
    requestId: "11111111-1111-4111-8111-111111111201"
  }' \
| curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "dave@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d @- \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/transactionPolicies")

echo "$POLICY_RESPONSE" | jq
export POLICY_NAME=$(echo "$POLICY_RESPONSE" | jq -r '.name')

Bitcoin, KMS

Cette règle autorise les transferts de bitcoins à l'aide du schéma BITCOIN_TX_V2 (BIP 174 PSBT v0) lorsque le montant net du transfert sortant ne dépasse pas 250 000 satoshis (context.amount_token_scaled <= 2500000, ou 0,0025 BTC normalisé à 10^-9 unités décimales fixes) et que les frais de minage ne dépassent pas 10 000 satoshis (context.max_fee_atomic <= 100000).

permit (principal, action, resource)
when {
  context.schema == "BITCOIN_TX_V2" &&
  context has amount_token_scaled &&
  context.amount_token_scaled <= 2500000 &&
  context.max_fee_atomic <= 100000
};

sign_policy() {
  local author_id=$1
  local resource_type=$2
  local resource_name=$3
  local action=$4
  local cedar_doc=$5
  python3 -c 'import sys; rt, rn, act, doc = sys.argv[1:]; v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("policy_payload.bin", "wb").write(f(1 if rt == "instance" else 2, rn.encode()) + bytes([24, 1 if act == "ACTIVATE" else 2]) + f(4, f(1, doc.encode())))' "${resource_type}" "${resource_name}" "${action}" "${cedar_doc}"
  gcloud kms asymmetric-sign \
    --version=1 \
    --key="${author_id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --digest-algorithm=sha256 \
    --input-file=policy_payload.bin \
    --signature-file=policy_sig.bin > /dev/null
  openssl base64 -A -in policy_sig.bin
}

export CEDAR_RULE='permit (principal, action, resource) when { context.schema == "BITCOIN_TX_V2" && context has amount_token_scaled && context.amount_token_scaled <= 2500000 && context.max_fee_atomic <= 100000 };'

# Sign as Policy Author 1
QUORUM_SIGNATURE=$(sign_policy "author-dave" "instance" "${INSTANCE_NAME}" "ACTIVATE" "${CEDAR_RULE}")
POLICY_PAYLOAD_B64=$(openssl base64 -A -in policy_payload.bin)

POLICY_RESPONSE=$(jq -n \
  --arg rule "$CEDAR_RULE" \
  --arg sig "$QUORUM_SIGNATURE" \
  --arg payload "$POLICY_PAYLOAD_B64" \
  '{
    transactionPolicy: {
      displayName: "Bitcoin PSBT Permit Policy",
      rule: {cedarDocument: $rule}
    },
    authorizationInfo: {
      signature: $sig,
      signedPayload: $payload
    },
    requestId: "11111111-1111-4111-8111-111111111202"
  }' \
| curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "dave@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d @- \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/transactionPolicies")

echo "$POLICY_RESPONSE" | jq
export POLICY_NAME=$(echo "$POLICY_RESPONSE" | jq -r '.name')

Bitcoin, OpenSSL

permit (principal, action, resource)
when {
  context.schema == "BITCOIN_TX_V2" &&
  context has amount_token_scaled &&
  context.amount_token_scaled <= 2500000 &&
  context.max_fee_atomic <= 100000
};

sign_policy() {
  local author_id=$1
  local resource_type=$2
  local resource_name=$3
  local action=$4
  local cedar_doc=$5
  python3 -c 'import sys; rt, rn, act, doc = sys.argv[1:]; v = lambda n: bytes([n & 127 | 128]) + v(n >> 7) if n > 127 else bytes([n]); f = lambda k, b: bytes([k << 3 | 2]) + v(len(b)) + b; open("policy_payload.bin", "wb").write(f(1 if rt == "instance" else 2, rn.encode()) + bytes([24, 1 if act == "ACTIVATE" else 2]) + f(4, f(1, doc.encode())))' "${resource_type}" "${resource_name}" "${action}" "${cedar_doc}"
  openssl dgst -sha256 -sign "${author_id}_priv.pem" -out policy_sig.bin policy_payload.bin
  openssl base64 -A -in policy_sig.bin
}

export CEDAR_RULE='permit (principal, action, resource) when { context.schema == "BITCOIN_TX_V2" && context has amount_token_scaled && context.amount_token_scaled <= 2500000 && context.max_fee_atomic <= 100000 };'

# Sign as Policy Author 1
QUORUM_SIGNATURE=$(sign_policy "author-dave" "instance" "${INSTANCE_NAME}" "ACTIVATE" "${CEDAR_RULE}")
POLICY_PAYLOAD_B64=$(openssl base64 -A -in policy_payload.bin)

POLICY_RESPONSE=$(jq -n \
  --arg rule "$CEDAR_RULE" \
  --arg sig "$QUORUM_SIGNATURE" \
  --arg payload "$POLICY_PAYLOAD_B64" \
  '{
    transactionPolicy: {
      displayName: "Bitcoin PSBT Permit Policy",
      rule: {cedarDocument: $rule}
    },
    authorizationInfo: {
      signature: $sig,
      signedPayload: $payload
    },
    requestId: "11111111-1111-4111-8111-111111111202"
  }' \
| curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "dave@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d @- \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/transactionPolicies")

echo "$POLICY_RESPONSE" | jq
export POLICY_NAME=$(echo "$POLICY_RESPONSE" | jq -r '.name')

B. Approuver la règle (passer à l'état ACTIVE)

Les modifications de stratégie nécessitent deux signatures sur deux. Par conséquent, un deuxième auteur de stratégie doit appeler transactionPolicies.approve (ApproveTransactionPolicy) avec un TransactionPolicySigningPayload signé.

Ethereum

# 1. Check the policy state
POLICY_INFO=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token "eve@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${POLICY_NAME}")

POLICY_STATE=$(echo "$POLICY_INFO" | jq -r '.state // "UNKNOWN"')

if [ "$POLICY_STATE" == "PENDING_ACTIVE" ]; then
  # 2. Sign as Policy Author 2 naming transaction_policy ($POLICY_NAME)
  QUORUM_SIGNATURE_2=$(sign_policy "author-eve" "transaction_policy" "${POLICY_NAME}" "ACTIVATE" "${CEDAR_RULE}")
  POLICY_PAYLOAD_2_B64=$(openssl base64 -A -in policy_payload.bin)

  # 3. Call ApproveTransactionPolicy as Policy Author 2
  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "eve@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"authorizationInfo\": {
        \"signature\": \"${QUORUM_SIGNATURE_2}\",
        \"signedPayload\": \"${POLICY_PAYLOAD_2_B64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${POLICY_NAME}:approve" | jq
elif [ "$POLICY_STATE" == "ACTIVE" ]; then
  echo "Policy '${POLICY_NAME}' is already ACTIVE. Skipping approval."
else
  echo "Policy '${POLICY_NAME}' is in an unexpected state: $POLICY_STATE"
fi

Bitcoin

# 1. Check the policy state
POLICY_INFO=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token "eve@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${POLICY_NAME}")

POLICY_STATE=$(echo "$POLICY_INFO" | jq -r '.state // "UNKNOWN"')

if [ "$POLICY_STATE" == "PENDING_ACTIVE" ]; then
  # 2. Sign as Policy Author 2 naming transaction_policy ($POLICY_NAME)
  QUORUM_SIGNATURE_2=$(sign_policy "author-eve" "transaction_policy" "${POLICY_NAME}" "ACTIVATE" "${CEDAR_RULE}")
  POLICY_PAYLOAD_2_B64=$(openssl base64 -A -in policy_payload.bin)

  # 3. Call ApproveTransactionPolicy as Policy Author 2
  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "eve@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"authorizationInfo\": {
        \"signature\": \"${QUORUM_SIGNATURE_2}\",
        \"signedPayload\": \"${POLICY_PAYLOAD_2_B64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${POLICY_NAME}:approve" | jq
elif [ "$POLICY_STATE" == "ACTIVE" ]; then
  echo "Policy '${POLICY_NAME}' is already ACTIVE. Skipping approval."
else
  echo "Policy '${POLICY_NAME}' is in an unexpected state: $POLICY_STATE"
fi

C. Créer et gérer une KeyList (facultatif)

Une KeyList (KeyListService) est une liste nommée d'adresses de blockchain (manualEntry, MPC key ou keyRing) que les règles peuvent référencer en tant que destinations de confiance. Les administrateurs (ADMIN) peuvent créer un KeyList avec keyLists.create et mettre à jour ses entrées à tout moment avec keyLists.addEntries et keyLists.removeEntries :

curl

KEY_LIST_RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d '{
    "displayName": "Approved Destinations",
    "description": "Trusted recipient addresses",
    "entries": [
      {
        "manualEntry": {
          "address": "0x1111111111111111111111111111111111111111",
          "source": "Treasury onboarding",
          "reason": "Approved recipient address"
        }
      }
    ]
  }' \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/keyLists?requestId=11111111-1111-4111-8111-111111111301")

echo "$KEY_LIST_RESPONSE" | jq
export KEY_LIST_NAME=$(echo "$KEY_LIST_RESPONSE" | jq -r '.name')

Étape 5 : Créez une clé

En tant qu'Admin 1 (admin-1@example.com), créez un KeyRing avec un KeyPolicy intégré et générez une clé MPC distribuée.

A. Créer un trousseau de clés avec une règle de clé intégrée

Un KeyRing est un regroupement logique de vos clés MPC. Il définit une KeyPolicy (keyRing.keyPolicy) intégrée immuable que chaque clé créée dans le KeyRing suit. Un KeyPolicy est une arborescence de règles de seuil (PolicyNode) dont l'élément enfant subKeyShares peut être teamNode (threshold de totalMembers dans un Team), userNode (un SIGNER User spécifique) ou un policyNode imbriqué.

Ici, nous configurons une règle de seuil 2 sur 3 pour les trois signataires dans ${TEAM_NAME} (threshold: 2, totalMembers: 3, stockés dans GCP_TEE) :

curl

KEY_RING_RESPONSE=$(jq -n \
  --arg team "${TEAM_NAME}" \
  '{
    displayName: "Treasury KeyRing",
    keyPolicy: {
      policy: {
        policyNodeId: "treasury-2-of-3",
        threshold: 1,
        subKeyShares: [
          {
            teamNode: {
              team: $team,
              threshold: 2,
              totalMembers: 3,
              storageInfo: {storageType: "GCP_TEE"}
            }
          }
        ]
      }
    }
  }' \
| curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d @- \
    "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/keyRings?requestId=11111111-1111-4111-8111-111111111401")

echo "$KEY_RING_RESPONSE" | jq
export KEY_RING_NAME=$(echo "$KEY_RING_RESPONSE" | jq -r '.name')
echo "Created KeyRing: $KEY_RING_NAME"

B. Générer une clé distribuée (DKG)

Appelez keys.create (CreateKey) en tant qu'administrateur 1 pour exécuter la génération de clés distribuées (DKG) sur les participants sélectionnés par le KeyPolicy de votre KeyRing.

CreateKey est synchrone et renvoie la ressource ACTIVE Key, y compris publicKeyInfo.publicKey et publicKeyInfo.blockchainAddresses dérivé du serveur (EC_SIGN_SECP256K1 pour Ethereum et Bitcoin, ou EC_SIGN_ED25519 pour Solana une fois qu'il est compatible) :

curl

KEY_RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d '{
    "algorithm": "EC_SIGN_SECP256K1"
  }' \
  "${INSTANCE_URL}/v1beta/${KEY_RING_NAME}/keys?requestId=11111111-1111-4111-8111-111111111501")

echo "$KEY_RESPONSE" | jq
export KEY_NAME=$(echo "$KEY_RESPONSE" | jq -r '.name')
export PUBLIC_KEY_B64=$(echo "$KEY_RESPONSE" | jq -r '.publicKeyInfo.publicKey')

C. Dériver l'adresse blockchain et localiser les UTXO

Une fois l'opération CreateKey terminée, publicKeyInfo.blockchainAddresses dans la réponse inclut automatiquement les adresses dérivées (secp256k1Addresses.ethereumAddress et secp256k1Addresses.bitcoinMainnetAddresses pour EC_SIGN_SECP256K1, ou ed25519Addresses.solanaAddress pour EC_SIGN_ED25519). Vous pouvez également vérifier ou dériver indépendamment les adresses Testnet et les scripts de verrouillage à partir de la clé publique non compressée de 65 octets (0x04 || X || Y) à l'aide des scripts suivants, et localiser les fonds non dépensés nécessaires aux transactions.

Ethereum

Les adresses Ethereum sont renvoyées dans .publicKeyInfo.blockchainAddresses.secp256k1Addresses.ethereumAddress et peuvent également être dérivées du hachage Keccak-256 du point de clé publique non compressé de 64 octets (pub_bytes[1:]), en prenant les 20 derniers octets.

Script de dérivation d'adresse (`derive_address.py`)

Exécutez le bloc suivant pour créer et exécuter derive_address.py :

cat <<'EOF' > derive_address.py
import base64
from eth_utils import keccak, to_checksum_address

# Insert your base64 publicKey from Step 5.B
PUBLIC_KEY_B64 = "your-public-key"

pub_bytes = base64.b64decode(PUBLIC_KEY_B64)
if len(pub_bytes) == 65 and pub_bytes[0] == 4:
    raw_addr = "0x" + keccak(pub_bytes[1:])[-20:].hex()
    checksummed_addr = to_checksum_address(raw_addr)
    print("Ethereum Address:", checksummed_addr)
else:
    print(f"Error: Expected 65-byte uncompressed key, got {len(pub_bytes)} bytes.")
EOF
python3 derive_address.py

Financer l'adresse Ethereum

Avant de diffuser à l'étape 7, assurez-vous que votre adresse Ethereum dérivée dispose de suffisamment d'ETH sur le réseau de test Sepolia pour couvrir la valeur de la transaction et les frais de gaz. Vous pouvez demander des ETH de testnet sans frais en saisissant votre nouvelle adresse dérivée dans le Faucet pour Ethereum Sepolia.

Bitcoin

Les adresses Bitcoin Mainnet (p2wpkhAddress, p2shP2wpkhAddress et p2pkhAddress) sont renvoyées dans .publicKeyInfo.blockchainAddresses.secp256k1Addresses.bitcoinMainnetAddresses. À partir de la clé publique EC secp256k1 non compressée de 65 octets (0x04 || X || Y), vous pouvez également dériver la clé publique compressée de 33 octets, les scripts de verrouillage et les adresses Testnet4 dans les trois formats :

SegWit natif (P2WPKH / BIP 173) : adresse Bech32 (bc1q... sur Mainnet, tb1q... sur Testnet4) avec un témoin de 22 octets scriptPubKey (0014<hash160>). Il s'agit du format moderne recommandé, avec les frais de transaction les plus bas.
SegWit imbriqué (P2SH-P2WPKH / BIP 49) : adresse SegWit encapsulée (3... sur Mainnet, 2... sur Testnet4) avec un scriptPubKey de 23 octets (a914<hash160>87) et un redeemScript de 22 octets (0014<hash160>), compatible avec les anciens systèmes.
Ancienne (P2PKH/BIP 44) : adresse Base58 Pay-to-PubKey-Hash d'origine (1... sur Mainnet, m/n... sur Testnet4) avec un scriptPubKey de 25 octets (76a914<hash160>88ac).

Script de dérivation d'adresse (`derive_btc_address.py`)

Exécutez le bloc suivant pour créer et exécuter derive_btc_address.py :

cat <<'EOF' > derive_btc_address.py
"""Derives Bitcoin addresses (Native SegWit, Nested SegWit, Legacy) from an MPC public key using embit."""

import base64
from embit import ec, script
from embit.networks import NETWORKS

# Insert the Base64-encoded public key from Step 5.B (publicKeyInfo.publicKey, decodes to 65 raw bytes)
PUBLIC_KEY_B64 = "your-public-key"

raw_bytes = base64.b64decode(PUBLIC_KEY_B64)
if len(raw_bytes) != 65 or raw_bytes[0] != 4:
  raise ValueError(f"Expected 65-byte uncompressed public key (0x04...), got {len(raw_bytes)} bytes")

# 1. Parse and compress public key to 33 bytes
pub = ec.PublicKey.parse(raw_bytes)
pub.compressed = True
compressed_pubkey_hex = pub.sec().hex()

print("================================================================")
print(f"Compressed Public Key (33 bytes): {compressed_pubkey_hex}")
print("================================================================")

# 2. Native SegWit (P2WPKH - BIP 173)
p2wpkh = script.p2wpkh(pub)
print("\n[1. Native SegWit (P2WPKH / Bech32 - BIP 173)]")
print(f"  ScriptPubKey:           {p2wpkh.data.hex()}")
print(f"  Testnet4 Address (tb):  {p2wpkh.address(NETWORKS['test'])}")
print(f"  Mainnet Address (bc):   {p2wpkh.address(NETWORKS['main'])}")

# 3. Nested SegWit (P2SH-P2WPKH - BIP 49)
p2sh_p2wpkh = script.p2sh(p2wpkh)
print("\n[2. Nested SegWit (P2SH-P2WPKH / Base58 - BIP 49)]")
print(f"  RedeemScript:           {p2wpkh.data.hex()}")
print(f"  ScriptPubKey:           {p2sh_p2wpkh.data.hex()}")
print(f"  Testnet4 Address (2):   {p2sh_p2wpkh.address(NETWORKS['test'])}")
print(f"  Mainnet Address (3):    {p2sh_p2wpkh.address(NETWORKS['main'])}")

# 4. Legacy (P2PKH - BIP 44)
p2pkh = script.p2pkh(pub)
print("\n[3. Legacy (P2PKH / Base58 - BIP 44)]")
print(f"  ScriptPubKey:           {p2pkh.data.hex()}")
print(f"  Testnet4 Address (m/n): {p2pkh.address(NETWORKS['test'])}")
print(f"  Mainnet Address (1):    {p2pkh.address(NETWORKS['main'])}")
EOF

python3 derive_btc_address.py

Localiser les sorties non dépensées (UTXO)

Contrairement aux blockchains basées sur des comptes, les transactions Bitcoin dépensent des sorties de transaction non dépensées (UTXO) spécifiques. Avant de créer une transaction à l'étape 6 :

Approvisionnez votre adresse Native SegWit dérivée (par exemple, à l'aide d'un faucet testnet).
Interrogez les UTXO non dépensés de votre adresse à l'aide de votre nœud Bitcoin (bitcoin-cli listunspent 1 9999999 "[\"tb1q...\"]") ou d'une API d'explorateur de blocs.
Notez les quatre paramètres suivants pour l'étape 6 :
- txid : hachage de transaction de 32 octets de la sortie non dépensée.
- vout : index de sortie basé sur zéro (par exemple, 0 ou 1).
- value : montant non dépensé en satoshis (par exemple, 200000 satoshis = 0,002 BTC).
- scriptPubKey : script de verrouillage hexadécimal (par exemple, 0014...).

Étape 6 : Exécuter une opération MPC

L'évaluation de la règle et le lancement de la signature se produisent ensemble lorsqu'un SIGNER appelle transactions.create (CreateTransaction). L'instance décode payload selon schema, évalue toutes les règles de transaction actives, enregistre le résultat dans policyEvaluationRecord et enregistre la décision AUTHORIZE du signataire initiateur.

A. Créer une transaction (évaluer la règle et lancer la signature)

Envoyez la transaction en tant que Signataire 1 (alice@example.com) pour l'évaluation et la signature de la stratégie :

Ethereum, KMS

🛑 Cas A : Refus (valeur trop élevée)

Essayez de créer une transaction de 3 ETH (ce qui dépasse la limite de 2 ETH définie par notre règle) :

sign_tx_decision() {
  local signer_id=$1
  local resource_type=$2
  local resource_name=$3
  local decision=$4
  local digest_hex=$5
  python3 -c 'import sys; rt, rn, dec, dg = sys.argv[1:]; f = lambda k, b: bytes([k << 3 | 2, len(b)]) + b; open("tx_decision_payload.bin", "wb").write(f(1 if rt == "key" else 2, rn.encode()) + bytes([24, 1 if dec == "AUTHORIZE" else 2]) + f(4, bytes.fromhex(dg)))' "${resource_type}" "${resource_name}" "${decision}" "${digest_hex}"
  gcloud kms asymmetric-sign \
    --version=1 \
    --key="${signer_id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --digest-algorithm=sha256 \
    --input-file=tx_decision_payload.bin \
    --signature-file=tx_decision_sig.bin > /dev/null
  openssl base64 -A -in tx_decision_sig.bin
}

# Payload for 3 ETH (amount_token_scaled = 3,000,000,000 > 2,000,000,000)
RAW_TX_BYTES_HEX="ef808504a817c8008252089411111111111111111111111111111111111111118829a2241af62c00008083aa36a78080"
PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$RAW_TX_BYTES_HEX')).decode('utf-8'))")
DIGEST_HEX=$(python3 -c "from eth_utils import keccak; print(keccak(bytes.fromhex('$RAW_TX_BYTES_HEX')).hex())")
DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"ETHEREUM_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111601\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions" | jq

Résultat attendu de l'évaluation de la règle : decision: DENY (denyReason: NO_PERMIT_RULE_MATCHED).

✅ Cas B : Approbation (valeur autorisée)

Créez une transaction de 1 Gwei (dans la limite de 2 ETH) :

# Payload for 1 Gwei
RAW_TX_BYTES_HEX="eb808504a817c800825208941111111111111111111111111111111111111111843b9aca008083aa36a78080"
PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$RAW_TX_BYTES_HEX')).decode('utf-8'))")
export DIGEST_HEX=$(python3 -c "from eth_utils import keccak; print(keccak(bytes.fromhex('$RAW_TX_BYTES_HEX')).hex())")
export DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"ETHEREUM_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111602\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions")

echo "$RESPONSE" | jq
export TRANSACTION_NAME=$(echo "$RESPONSE" | jq -r '.name')

Réponse attendue : state: PENDING_AUTHORIZATION et policyEvaluationRecord.decision: PERMIT.

Ethereum, OpenSSL

🛑 Cas A : Refus (valeur trop élevée)

Essayez de créer une transaction de 3 ETH (ce qui dépasse la limite de 2 ETH définie par notre règle) :

sign_tx_decision() {
  local signer_id=$1
  local resource_type=$2
  local resource_name=$3
  local decision=$4
  local digest_hex=$5
  python3 -c 'import sys; rt, rn, dec, dg = sys.argv[1:]; f = lambda k, b: bytes([k << 3 | 2, len(b)]) + b; open("tx_decision_payload.bin", "wb").write(f(1 if rt == "key" else 2, rn.encode()) + bytes([24, 1 if dec == "AUTHORIZE" else 2]) + f(4, bytes.fromhex(dg)))' "${resource_type}" "${resource_name}" "${decision}" "${digest_hex}"
  openssl dgst -sha256 -sign "${signer_id}_priv.pem" -out tx_decision_sig.bin tx_decision_payload.bin
  openssl base64 -A -in tx_decision_sig.bin
}

# Payload for 3 ETH (amount_token_scaled = 3,000,000,000 > 2,000,000,000)
RAW_TX_BYTES_HEX="ef808504a817c8008252089411111111111111111111111111111111111111118829a2241af62c00008083aa36a78080"
PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$RAW_TX_BYTES_HEX')).decode('utf-8'))")
DIGEST_HEX=$(python3 -c "from eth_utils import keccak; print(keccak(bytes.fromhex('$RAW_TX_BYTES_HEX')).hex())")
DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"ETHEREUM_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111601\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions" | jq

Résultat attendu de l'évaluation de la règle : decision: DENY (denyReason: NO_PERMIT_RULE_MATCHED).

✅ Cas B : Approbation (valeur autorisée)

Créez une transaction de 1 Gwei (dans la limite de 2 ETH) :

# Payload for 1 Gwei
RAW_TX_BYTES_HEX="eb808504a817c800825208941111111111111111111111111111111111111111843b9aca008083aa36a78080"
PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$RAW_TX_BYTES_HEX')).decode('utf-8'))")
export DIGEST_HEX=$(python3 -c "from eth_utils import keccak; print(keccak(bytes.fromhex('$RAW_TX_BYTES_HEX')).hex())")
export DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"ETHEREUM_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111602\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions")

echo "$RESPONSE" | jq
export TRANSACTION_NAME=$(echo "$RESPONSE" | jq -r '.name')

Réponse attendue : state: PENDING_AUTHORIZATION et policyEvaluationRecord.decision: PERMIT.

Bitcoin, KMS

Dans le modèle UTXO de Bitcoin, les transactions dépensent des sorties non dépensées spécifiques. Dans SegWit (BIP 143), le calcul du hachage de signature nécessite de connaître le montant en satoshis et le script de verrouillage de l'entrée dépensée.

L'évaluation de la règle Bitcoin nécessite le format BIP 174 PSBT v0 (BITCOIN_TX_V2) avec PSBT_IN_WITNESS_UTXO renseigné pour chaque entrée.

Script de construction PSBT (`build_psbt.py`)

Exécutez le bloc suivant pour assembler une charge utile PSBT v0 BIP 174 valide :

cat <<'EOF' > build_psbt.py
"""Constructs a BIP 174 PSBT v0 payload using embit for Bitcoin policy evaluation."""

from embit import script, transaction
from embit.psbt import PSBT

# 1. Inputs (From Step 5.C)
PREV_TXID_HEX = "8f594f33156993f1c980c2273dcae4a92cf2517fbc29264421395e63a63916d8"
PREV_VOUT = int("1")
INPUT_VALUE_SATS = int("200000")  # Total UTXO input value in satoshis
SENDER_SCRIPTPUBKEY_HEX = "0014eced05cd51d964102a20c856b09080ad620e9da2"

# 2. Output Allocations
RECIPIENT_SATS = int("50000")  # Recipient payment in satoshis
MINER_FEE_SATS = int("250")  # Miner fee in satoshis
RECIPIENT_SCRIPTPUBKEY_HEX = "0014751e76e8199196d454941c45d1b3a323f1433bd6"

# Change Output calculation: InputSats - RecipientSats - MinerFeeSats
CHANGE_SATS = INPUT_VALUE_SATS - RECIPIENT_SATS - MINER_FEE_SATS
if CHANGE_SATS <= 0:
  raise ValueError(f"Insufficient input satoshis ({INPUT_VALUE_SATS}) for payment and fee")

# 3. Construct Unsigned Transaction (Version 2, 1 input, 2 outputs, locktime 0)
tx = transaction.Transaction(
    version=2,
    vin=[transaction.TransactionInput(
        txid=bytes.fromhex(PREV_TXID_HEX),
        vout=PREV_VOUT,
        sequence=0xFFFFFFFF,
    )],
    vout=[
        transaction.TransactionOutput(
            value=RECIPIENT_SATS,
            script_pubkey=script.Script(bytes.fromhex(RECIPIENT_SCRIPTPUBKEY_HEX)),
        ),
        transaction.TransactionOutput(
            value=CHANGE_SATS,
            script_pubkey=script.Script(bytes.fromhex(SENDER_SCRIPTPUBKEY_HEX)),
        ),
    ],
    locktime=0,
)

# 4. Package into BIP 174 PSBT with Input Witness UTXO
psbt = PSBT(tx)
psbt.inputs[0].witness_utxo = transaction.TransactionOutput(
    value=INPUT_VALUE_SATS,
    script_pubkey=script.Script(bytes.fromhex(SENDER_SCRIPTPUBKEY_HEX)),
)

print(psbt.serialize().hex())
EOF

BTC_PSBT_HEX=$(python3 build_psbt.py)
echo "Generated PSBT Hex (${#BTC_PSBT_HEX} chars):"
echo "$BTC_PSBT_HEX"

🛑 Cas A : Refus (limite de frais dépassée)

Tentative de création d'une transaction dont les frais de minage dépassent la limite de 10 000 satoshis définie par les règles. Dans cet exemple, la définition de MINER_FEE_SATS = 15000 (et CHANGE_SATS = 135000) dans build_psbt.py passe à max_fee_atomic = 150000 (dépassant le plafond de la règle de 100000), ce qui produit la charge utile suivante qui déclenche une décision d'évaluation de la règle DENY.

sign_tx_decision() {
  local signer_id=$1
  local resource_type=$2
  local resource_name=$3
  local decision=$4
  local digest_hex=$5
  python3 -c 'import sys; rt, rn, dec, dg = sys.argv[1:]; f = lambda k, b: bytes([k << 3 | 2, len(b)]) + b; open("tx_decision_payload.bin", "wb").write(f(1 if rt == "key" else 2, rn.encode()) + bytes([24, 1 if dec == "AUTHORIZE" else 2]) + f(4, bytes.fromhex(dg)))' "${resource_type}" "${resource_name}" "${decision}" "${digest_hex}"
  gcloud kms asymmetric-sign \
    --version=1 \
    --key="${signer_id}-key" \
    --keyring="mpc-assent-keys" \
    --location="us-central1" \
    --digest-algorithm=sha256 \
    --input-file=tx_decision_payload.bin \
    --signature-file=tx_decision_sig.bin > /dev/null
  openssl base64 -A -in tx_decision_sig.bin
}

# Construct a PSBT payload with miner_fee_sats = 15000 -> max_fee_atomic = 150000 (exceeds 100000 limit)
REJECTED_PSBT_HEX="70736274ff0100710200000001d81639a6635e3921442629bc7f51f22ca9e4ca3d27c280c9f1936915334f598f0100000000ffffffff0250c3000000000000160014751e76e8199196d454941c45d1b3a323f1433bd6580f020000000000160014eced05cd51d964102a20c856b09080ad620e9da2000000000001011f400d030000000000160014eced05cd51d964102a20c856b09080ad620e9da2000000"
REJECTED_PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$REJECTED_PSBT_HEX')).decode('utf-8'))")
REJECTED_DIGEST_HEX=$(python3 -c "from embit import script; from embit.psbt import PSBT; p=PSBT.parse(bytes.fromhex('$REJECTED_PSBT_HEX')); u=p.inputs[0].witness_utxo; sc=script.Script(b'\x76\xa9\x14'+u.script_pubkey.data[2:]+b'\x88\xac'); print(p.tx.sighash_segwit(0, sc, u.value).hex())")
REJECTED_DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$REJECTED_DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${REJECTED_DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"BITCOIN_TX_V2\",
      \"payload\": \"${REJECTED_PAYLOAD_B64}\",
      \"digest\": \"${REJECTED_DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111603\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions" | jq

Résultat attendu de l'évaluation de la règle : decision: DENY (denyReason: NO_PERMIT_RULE_MATCHED).

✅ Cas B : approbation (PSBT Bitcoin autorisé)

Créez une transaction avec la PSBT valide précédemment construite (RECIPIENT_SATS = 50000 correspond à amount_token_scaled = 500000 <= 2500000 et MINER_FEE_SATS = 250 correspond à max_fee_atomic = 2500 <= 100000) :

PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$BTC_PSBT_HEX')).decode('utf-8'))")
export DIGEST_HEX=$(python3 -c "from embit import script; from embit.psbt import PSBT; p=PSBT.parse(bytes.fromhex('$BTC_PSBT_HEX')); u=p.inputs[0].witness_utxo; sc=script.Script(b'\x76\xa9\x14'+u.script_pubkey.data[2:]+b'\x88\xac'); print(p.tx.sighash_segwit(0, sc, u.value).hex())")
export DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"BITCOIN_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111604\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions")

echo "$RESPONSE" | jq
export TRANSACTION_NAME=$(echo "$RESPONSE" | jq -r '.name')

Réponse attendue : state: PENDING_AUTHORIZATION et policyEvaluationRecord.decision: PERMIT.

Bitcoin, OpenSSL

L'évaluation de la règle Bitcoin nécessite le format BIP 174 PSBT v0 (BITCOIN_TX_V2) avec PSBT_IN_WITNESS_UTXO renseigné pour chaque entrée.

Script de construction PSBT (`build_psbt.py`)

Exécutez le bloc suivant pour assembler une charge utile PSBT v0 BIP 174 valide :

cat <<'EOF' > build_psbt.py
"""Constructs a BIP 174 PSBT v0 payload using embit for Bitcoin policy evaluation."""

from embit import script, transaction
from embit.psbt import PSBT

# 1. Inputs (From Step 5.C)
PREV_TXID_HEX = "8f594f33156993f1c980c2273dcae4a92cf2517fbc29264421395e63a63916d8"
PREV_VOUT = int("1")
INPUT_VALUE_SATS = int("200000")  # Total UTXO input value in satoshis
SENDER_SCRIPTPUBKEY_HEX = "0014eced05cd51d964102a20c856b09080ad620e9da2"

# 2. Output Allocations
RECIPIENT_SATS = int("50000")  # Recipient payment in satoshis
MINER_FEE_SATS = int("250")  # Miner fee in satoshis
RECIPIENT_SCRIPTPUBKEY_HEX = "0014751e76e8199196d454941c45d1b3a323f1433bd6"

# Change Output calculation: InputSats - RecipientSats - MinerFeeSats
CHANGE_SATS = INPUT_VALUE_SATS - RECIPIENT_SATS - MINER_FEE_SATS
if CHANGE_SATS <= 0:
  raise ValueError(f"Insufficient input satoshis ({INPUT_VALUE_SATS}) for payment and fee")

# 3. Construct Unsigned Transaction (Version 2, 1 input, 2 outputs, locktime 0)
tx = transaction.Transaction(
    version=2,
    vin=[transaction.TransactionInput(
        txid=bytes.fromhex(PREV_TXID_HEX),
        vout=PREV_VOUT,
        sequence=0xFFFFFFFF,
    )],
    vout=[
        transaction.TransactionOutput(
            value=RECIPIENT_SATS,
            script_pubkey=script.Script(bytes.fromhex(RECIPIENT_SCRIPTPUBKEY_HEX)),
        ),
        transaction.TransactionOutput(
            value=CHANGE_SATS,
            script_pubkey=script.Script(bytes.fromhex(SENDER_SCRIPTPUBKEY_HEX)),
        ),
    ],
    locktime=0,
)

# 4. Package into BIP 174 PSBT with Input Witness UTXO
psbt = PSBT(tx)
psbt.inputs[0].witness_utxo = transaction.TransactionOutput(
    value=INPUT_VALUE_SATS,
    script_pubkey=script.Script(bytes.fromhex(SENDER_SCRIPTPUBKEY_HEX)),
)

print(psbt.serialize().hex())
EOF

BTC_PSBT_HEX=$(python3 build_psbt.py)
echo "Generated PSBT Hex (${#BTC_PSBT_HEX} chars):"
echo "$BTC_PSBT_HEX"

🛑 Cas A : Refus (limite de frais dépassée)

sign_tx_decision() {
  local signer_id=$1
  local resource_type=$2
  local resource_name=$3
  local decision=$4
  local digest_hex=$5
  python3 -c 'import sys; rt, rn, dec, dg = sys.argv[1:]; f = lambda k, b: bytes([k << 3 | 2, len(b)]) + b; open("tx_decision_payload.bin", "wb").write(f(1 if rt == "key" else 2, rn.encode()) + bytes([24, 1 if dec == "AUTHORIZE" else 2]) + f(4, bytes.fromhex(dg)))' "${resource_type}" "${resource_name}" "${decision}" "${digest_hex}"
  openssl dgst -sha256 -sign "${signer_id}_priv.pem" -out tx_decision_sig.bin tx_decision_payload.bin
  openssl base64 -A -in tx_decision_sig.bin
}

# Construct a PSBT payload with miner_fee_sats = 15000 -> max_fee_atomic = 150000 (exceeds 100000 limit)
REJECTED_PSBT_HEX="70736274ff0100710200000001d81639a6635e3921442629bc7f51f22ca9e4ca3d27c280c9f1936915334f598f0100000000ffffffff0250c3000000000000160014751e76e8199196d454941c45d1b3a323f1433bd6580f020000000000160014eced05cd51d964102a20c856b09080ad620e9da2000000000001011f400d030000000000160014eced05cd51d964102a20c856b09080ad620e9da2000000"
REJECTED_PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$REJECTED_PSBT_HEX')).decode('utf-8'))")
REJECTED_DIGEST_HEX=$(python3 -c "from embit import script; from embit.psbt import PSBT; p=PSBT.parse(bytes.fromhex('$REJECTED_PSBT_HEX')); u=p.inputs[0].witness_utxo; sc=script.Script(b'\x76\xa9\x14'+u.script_pubkey.data[2:]+b'\x88\xac'); print(p.tx.sighash_segwit(0, sc, u.value).hex())")
REJECTED_DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$REJECTED_DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${REJECTED_DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"BITCOIN_TX_V2\",
      \"payload\": \"${REJECTED_PAYLOAD_B64}\",
      \"digest\": \"${REJECTED_DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111603\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions" | jq

Résultat attendu de l'évaluation de la règle : decision: DENY (denyReason: NO_PERMIT_RULE_MATCHED).

✅ Cas B : approbation (PSBT Bitcoin autorisé)

PAYLOAD_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$BTC_PSBT_HEX')).decode('utf-8'))")
export DIGEST_HEX=$(python3 -c "from embit import script; from embit.psbt import PSBT; p=PSBT.parse(bytes.fromhex('$BTC_PSBT_HEX')); u=p.inputs[0].witness_utxo; sc=script.Script(b'\x76\xa9\x14'+u.script_pubkey.data[2:]+b'\x88\xac'); print(p.tx.sighash_segwit(0, sc, u.value).hex())")
export DIGEST_B64=$(python3 -c "import base64; print(base64.b64encode(bytes.fromhex('$DIGEST_HEX')).decode('utf-8'))")

SIGNER_1_SIG_B64=$(sign_tx_decision "signer-alice" "key" "${KEY_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
SIGNED_DECISION_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

RESPONSE=$(curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  -H "Content-Type: application/json" \
  -d "{
    \"transaction\": {
      \"action\": \"Action::\\\"Transfer\\\"\",
      \"schema\": \"BITCOIN_TX_V2\",
      \"payload\": \"${PAYLOAD_B64}\",
      \"digest\": \"${DIGEST_B64}\"
    },
    \"authorizationInfo\": {
      \"signature\": \"${SIGNER_1_SIG_B64}\",
      \"signedPayload\": \"${SIGNED_DECISION_PAYLOAD_B64}\"
    },
    \"requestId\": \"11111111-1111-4111-8111-111111111604\"
  }" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions")

echo "$RESPONSE" | jq
export TRANSACTION_NAME=$(echo "$RESPONSE" | jq -r '.name')

Réponse attendue : state: PENDING_AUTHORIZATION et policyEvaluationRecord.decision: PERMIT.

🕵️‍♂️ Vérifier l'état de la transaction (interrogation)

Interrogez régulièrement l'état de la transaction en exécutant la commande suivante :

curl

curl -s -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${TRANSACTION_NAME}" | jq

B. Enregistrer la décision du signataire (autoriser)

Étant donné que CreateTransaction à l'étape 6.A a déjà enregistré la décision AUTHORIZE du signataire 1 (1 sur 2 requise par le seuil KeyPolicy de 2 sur 3), un seul cosignataire supplémentaire détenant un partage de clé doit autoriser la transaction à l'aide de transactions.recordSignerDecision (RecordSignerDecision).

Signez le TransactionSigningPayload en nommant transaction (${TRANSACTION_NAME}) et appelez recordSignerDecision en tant que Signataire 2 (bob@example.com) :

curl

# 1. Check state for Signer 2
TX_INFO=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token "bob@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${TRANSACTION_NAME}")

TX_STATE=$(echo "$TX_INFO" | jq -r '.state // "UNKNOWN"')

if [ "$TX_STATE" == "PENDING_AUTHORIZATION" ]; then
  # 2. Sign as Signer 2 naming transaction ($TRANSACTION_NAME)
  SIGNER_2_SIG_B64=$(sign_tx_decision "signer-bob" "transaction" "${TRANSACTION_NAME}" "AUTHORIZE" "${DIGEST_HEX}")
  SIGNER_2_PAYLOAD_B64=$(openssl base64 -A -in tx_decision_payload.bin)

  # 3. Call RecordSignerDecision as Signer 2
  echo "Recording AUTHORIZE decision for Signer 2..."
  curl -s -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token "bob@example.com")" \
    -H "X-Goog-User-Project: my-project" \
    -H "Content-Type: application/json" \
    -d "{
      \"decision\": \"AUTHORIZE\",
      \"authorizationInfo\": {
        \"signature\": \"${SIGNER_2_SIG_B64}\",
        \"signedPayload\": \"${SIGNER_2_PAYLOAD_B64}\"
      }
    }" \
    "${INSTANCE_URL}/v1beta/${TRANSACTION_NAME}:recordSignerDecision" | jq
elif [ "$TX_STATE" == "SIGNING" ] || [ "$TX_STATE" == "SIGNING_SUCCEEDED" ]; then
  echo "Transaction is in state $TX_STATE. Skipping Signer 2."
else
  echo "Transaction is in an unexpected state: $TX_STATE"
fi

C. Récupérer la signature finale

Une fois le seuil d'autorisations atteint, vérifiez l'état de la transaction et récupérez finalSignature (et recoveryId pour les clés EC_SIGN_SECP256K1) :

curl

curl -s -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token "alice@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${TRANSACTION_NAME}" | jq

Lorsque state est SIGNING_SUCCEEDED, copiez le champ finalSignature à partir du JSON renvoyé pour l'étape 7.

Étape 7 : Diffuser la transaction sur la blockchain

Une fois que votre transaction a atteint l'état SIGNING_SUCCEEDED et que vous avez récupéré le finalSignature, la dernière étape consiste à construire la transaction filaire signée et à la diffuser sur le réseau.

Ethereum

Dérivation et diffusion de l'identifiant de récupération

L'API MPC renvoie une signature ECDSA brute de 64 octets dans finalSignature (comprenant les valeurs r et s de 32 octets au format canonique low-S conformément à l'EIP-2), ainsi que le bit de parité de récupération (0 ou 1) dans recoveryId.

Le script Python suivant construit la transaction signée à l'aide de votre finalSignature, vérifie l'adresse de l'expéditeur récupérée par rapport à l'adresse Ethereum de votre clé MPC et la diffuse sur le réseau.

Script de l'annonce :

Exécutez le bloc suivant dans votre terminal pour écrire et exécuter broadcast_eth.py :

cat <<'EOF' > broadcast_eth.py
"""Broadcasts an Ethereum transaction using a normalized MPC signature."""

import base64
import os
import requests
from eth_account import Account
try:
    from eth_account._utils.transactions import encode_transaction, serializable_unsigned_transaction_from_dict
except ImportError:
    from eth_account._utils.legacy_transactions import encode_transaction, serializable_unsigned_transaction_from_dict

# ==========================================
# 1. INPUTS
# ==========================================
FINAL_SIGNATURE_B64 = "your-final-signature"
RPC_URL = "https://ethereum-sepolia-rpc.publicnode.com"
EXPECTED_SENDER = "0xyour-mpc-key-address"

if not FINAL_SIGNATURE_B64 or FINAL_SIGNATURE_B64 == "your-final-signature":
    raise ValueError("FINAL_SIGNATURE_B64 is not set. Please provide a valid signature.")

# ==========================================
# 2. TRANSACTION PARAMETERS
# ==========================================
CHAIN_ID = 11155111  # Sepolia Testnet
tx_dict = {
    "nonce": int("0"),
    "gasPrice": int("20000000000"),  # 20 Gwei
    "gas": int("21000"),
    "to": "0x1111111111111111111111111111111111111111",
    "value": int("1000000000"),  # 1 Gwei
    "data": b"",
    "chainId": CHAIN_ID,
}

# ==========================================
# 3. DECODE & SPLIT SIGNATURE
# ==========================================
missing_padding = len(FINAL_SIGNATURE_B64) % 4
if missing_padding:
    FINAL_SIGNATURE_B64 += "=" * (4 - missing_padding)

sig_bytes = base64.b64decode(FINAL_SIGNATURE_B64)
r = int.from_bytes(sig_bytes[:32], byteorder="big")
s = int.from_bytes(sig_bytes[32:], byteorder="big")

# ==========================================
# 4. RECOVERY IDENTIFIER (V) DERIVATION
# ==========================================
chain_v_base = (CHAIN_ID * 2) + 35

# ==========================================
# 5. GENERATE UNSIGNED TX & RECOVER SENDER ADDRESS
# ==========================================
unsigned_tx = serializable_unsigned_transaction_from_dict(tx_dict)

derived_sender = None
encoded_tx = None
final_v = chain_v_base

EXPECTED_SENDER_PLACEHOLDER = "0xyour-mpc-key-address"
is_valid_expected = EXPECTED_SENDER and EXPECTED_SENDER != EXPECTED_SENDER_PLACEHOLDER

for parity in [0, 1]:
    try_v = chain_v_base + parity
    try:
        tx_candidate = encode_transaction(unsigned_tx, vrs=(try_v, r, s))
        addr = Account.recover_transaction("0x" + tx_candidate.hex())

        if is_valid_expected and EXPECTED_SENDER.lower() == addr.lower():
            derived_sender = addr
            final_v = try_v
            encoded_tx = tx_candidate
            break

        if not is_valid_expected and derived_sender is None:
            derived_sender = addr
            final_v = try_v
            encoded_tx = tx_candidate
            print(f"Warning: EXPECTED_SENDER not provided or is placeholder. Assuming first recovered address: {addr}")

    except Exception:
        continue

if encoded_tx is None:
    if is_valid_expected:
        raise ValueError(f"Could not recover address matching EXPECTED_SENDER: {EXPECTED_SENDER}")
    else:
        raise ValueError("Could not derive broadcastable transaction. Ensure signature matches payload.")

if derived_sender:
    print(f"Derived Sender Address: {derived_sender}")
else:
    print("Derived Sender Address: Could not recover (ensure signature matches current transaction payload)")

valid_tx_hex = "0x" + encoded_tx.hex()
print(f"Broadcastable Transaction Hex:\n{valid_tx_hex}\n")

# ==========================================
# 6. BROADCAST TO NETWORK
# ==========================================
payload = {
    "jsonrpc": "2.0",
    "method": "eth_sendRawTransaction",
    "params": [valid_tx_hex],
    "id": 1,
}

print(f"Broadcasting to {RPC_URL}...")
response = requests.post(RPC_URL, json=payload)
resp_json = response.json()
print("RPC Response:", resp_json)
if "result" in resp_json:
    tx_hash = resp_json["result"]
    print(f"View transaction on Sepolia Etherscan: https://sepolia.etherscan.io/tx/{tx_hash}")
EOF

python3 broadcast_eth.py

Dépannage des erreurs courantes

invalid sender: recovery failed ou invalid transaction v, r, s values : cela se produit si les paramètres de transaction de votre script ne correspondent pas exactement à la charge utile signée. Assurez-vous que les champs value, nonce et to correspondent à ce qui a été traité à l'étape 6.
insufficient funds for gas * price + value : votre transaction est valide d'un point de vue cryptographique et a été acceptée par le nœud, mais l'adresse Ethereum de votre clé MPC ne dispose pas d'assez d'ETH testnet pour couvrir l'opération. Vous devrez approvisionner votre adresse avant de diffuser.

Bitcoin

Assemblage et diffusion des transactions SegWit Wire

Pour les transactions Bitcoin Native SegWit (BIP 141), la signature MPC (r, s) brute de 64 octets doit être formatée en ASN.1 DER canonique low-S, suivie de 0x01 (SIGHASH_ALL), et assemblée avec la clé publique compressée de 33 octets dans la pile de témoins SegWit à deux éléments : [DER signature || 0x01, compressed public key].

Script de l'annonce :

Exécutez le bloc suivant pour créer et exécuter broadcast_btc.py :

cat <<'EOF' > broadcast_btc.py
"""Assembles a signed Bitcoin Native SegWit transaction from an MPC signature using embit and broadcasts it."""

import base64
import urllib.request
from embit import ec, script, transaction

# ==========================================
# 1. INPUTS
# ==========================================
FINAL_SIGNATURE_B64 = "your-final-signature"
COMPRESSED_PUBKEY_HEX = "03deb76948c14003446a8c1d79e88fb3607c9bbc1f5143b186aa7b61d6b1facc36"

PREV_TXID_HEX = "8f594f33156993f1c980c2273dcae4a92cf2517fbc29264421395e63a63916d8"
PREV_VOUT = int("1")

RECIPIENT_SATS = int("50000")
RECIPIENT_SCRIPTPUBKEY_HEX = "0014751e76e8199196d454941c45d1b3a323f1433bd6"

CHANGE_SATS = int("149750")
CHANGE_SCRIPTPUBKEY_HEX = "0014eced05cd51d964102a20c856b09080ad620e9da2"

BROADCAST_API_URL = "https://mempool.space/testnet4/api/tx"

# ==========================================
# 2. CONVERT RAW (r, s) SIGNATURE TO CANONICAL LOW-S ASN.1 DER + SIGHASH_ALL
# ==========================================
sig_bytes = base64.b64decode(FINAL_SIGNATURE_B64)
internal_sig = ec.secp256k1.ecdsa_signature_parse_compact(sig_bytes)
ec.secp256k1.ecdsa_signature_normalize(internal_sig, internal_sig)
der_sig = ec.secp256k1.ecdsa_signature_serialize_der(internal_sig) + b"\x01"  # 0x01 = SIGHASH_ALL

# ==========================================
# 3. BUILD TRANSACTION & ATTACH SEGWIT WITNESS STACK
# ==========================================
tx = transaction.Transaction(
    version=2,
    vin=[transaction.TransactionInput(
        txid=bytes.fromhex(PREV_TXID_HEX),
        vout=PREV_VOUT,
        sequence=0xFFFFFFFF,
    )],
    vout=[
        transaction.TransactionOutput(
            value=RECIPIENT_SATS,
            script_pubkey=script.Script(bytes.fromhex(RECIPIENT_SCRIPTPUBKEY_HEX)),
        ),
        transaction.TransactionOutput(
            value=CHANGE_SATS,
            script_pubkey=script.Script(bytes.fromhex(CHANGE_SCRIPTPUBKEY_HEX)),
        ),
    ],
    locktime=0,
)

pubkey_bytes = bytes.fromhex(COMPRESSED_PUBKEY_HEX)
tx.vin[0].witness = transaction.Witness([der_sig, pubkey_bytes])

signed_tx_hex = tx.serialize().hex()
print("--- Signed Bitcoin SegWit Wire Transaction Hex ---")
print(signed_tx_hex)

# ==========================================
# 4. BROADCAST TO NETWORK
# ==========================================
if BROADCAST_API_URL:
  print(f"\nBroadcasting to {BROADCAST_API_URL}...")
  try:
    req = urllib.request.Request(
        BROADCAST_API_URL,
        data=signed_tx_hex.encode("utf-8"),
        headers={"Content-Type": "text/plain"},
        method="POST",
    )
    with urllib.request.urlopen(req) as resp:
      txid_result = resp.read().decode("utf-8").strip()
      print(f"✅ Broadcast Successful! Transaction ID (txid): {txid_result}")
      print(f"Track in Mempool Explorer: https://mempool.space/testnet4/tx/{txid_result}")
  except Exception as e:
    print(f"Broadcast response: {e}")
EOF

python3 broadcast_btc.py

Dépannage des erreurs courantes

mandatory-script-verify-flag-failed (Signature must be zero for failed CHECK(MULTI)SIG operation) / non-mandatory-script-verify-flag (Non-canonical DER signature) : assurez-vous que le composant s de la signature est au format canonique low-s (s <= N/2) et correctement encodé en DER.
bad-txns-in-belowout / bad-txns-fee-negative : le total des sorties dépasse la valeur d'entrée. Assurez-vous que le calcul de la variation (InputSatoshis - PaymentSatoshis - MinerFee) est strictement positif.

📖 Annexe : Guide opérationnel (interrogation et inspection)

Utilisez ces commandes pour inspecter et gérer l'état de vos ressources à tout moment.

🏢 1. Instances

Inspectez et gérez les instances MPC dans votre projet et votre emplacement.

A. Lister toutes les instances

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "https://mpc.googleapis.com/v1beta/projects/my-project/locations/us-central1/instances" | jq

B. Obtenir les détails d'une instance spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "https://mpc.googleapis.com/v1beta/${INSTANCE_NAME}" | jq

👥 2. Équipes et utilisateurs

Inspectez les équipes et les utilisateurs de votre instance.

A. Lister toutes les équipes

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/teams" | jq

B. Obtenir des détails sur une équipe spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${TEAM_NAME}" | jq

C. Lister tous les utilisateurs enregistrés

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/users" | jq

D. Obtenir des détails sur un utilisateur spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${SIGNER_1_NAME}" | jq

📜 3. Règles de transaction et KeyLists

Inspectez les règles de transaction et les listes de clés.

A. Répertorier toutes les règles de transaction

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/transactionPolicies" | jq

B. Obtenir les détails d'une règle de transaction spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${POLICY_NAME}" | jq

C. Lister et obtenir des KeyLists

curl

# List all KeyLists
curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/keyLists" | jq

# Get a specific KeyList
curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${KEY_LIST_NAME}" | jq

🔑 4. Clés et trousseaux de clés

Inspecter les trousseaux de clés et les clés distribuées.

A. Lister tous les trousseaux de clés

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/keyRings" | jq

B. Répertorier toutes les clés d'un trousseau de clés

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${KEY_RING_NAME}/keys" | jq

C. Obtenir des détails sur une clé distribuée spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}" | jq

📝 5. Transactions (opérations de signature)

Inspectez les transactions et l'état de la signature.

A. Répertorier toutes les transactions pour une clé (ou pour toutes les clés)

curl

# List transactions for a specific Key
curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${KEY_NAME}/transactions" | jq

# List transactions across all KeyRings and Keys using the '-' wildcard
curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${INSTANCE_NAME}/keyRings/-/keys/-/transactions" | jq

B. Obtenir des détails ou l'état d'une transaction spécifique

curl

curl -H "Authorization: Bearer $(gcloud auth print-access-token "admin-1@example.com")" \
  -H "X-Goog-User-Project: my-project" \
  "${INSTANCE_URL}/v1beta/${TRANSACTION_NAME}" | jq

Guide de l'utilisateur sur le calcul multipartite Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Présentation

Prérequis

Configuration

Configuration requise

Libellés de ressource du tutoriel

Étape 1 : Créez une instance MPC

A. Créer l'instance

curl

🕵️‍♂️ Vérifier l'état de l'instance (interrogation)

curl

Étape 2 : Générer des clés d'autorisation

Cloud KMS

OpenSSL

Étape 3 : Enregistrez les équipes et les utilisateurs

A. Créer une équipe de signataires

curl

B. Attribuer des rôles IAM et enregistrer des signataires et des auteurs de règles

curl

C. Attribuer le rôle d'auteur de règles (approbation par quorum d'administrateurs)

Cloud KMS

OpenSSL

Étape 4 : Configurer les règles de transaction

A. Créer une règle (PENDING_ACTIVE)

Ethereum, KMS

Ethereum, OpenSSL

Bitcoin, KMS

Bitcoin, OpenSSL

B. Approuver la règle (passer à l'état ACTIVE)

Ethereum

Bitcoin

C. Créer et gérer une KeyList (facultatif)

curl

Étape 5 : Créez une clé

A. Créer un trousseau de clés avec une règle de clé intégrée

curl

B. Générer une clé distribuée (DKG)

curl

C. Dériver l'adresse blockchain et localiser les UTXO

Ethereum

Script de dérivation d'adresse (derive_address.py)

Financer l'adresse Ethereum

Bitcoin

Script de dérivation d'adresse (derive_btc_address.py)

Localiser les sorties non dépensées (UTXO)

Étape 6 : Exécuter une opération MPC

A. Créer une transaction (évaluer la règle et lancer la signature)

Ethereum, KMS

🛑 Cas A : Refus (valeur trop élevée)

✅ Cas B : Approbation (valeur autorisée)

Ethereum, OpenSSL

🛑 Cas A : Refus (valeur trop élevée)

✅ Cas B : Approbation (valeur autorisée)

Bitcoin, KMS

Script de construction PSBT (build_psbt.py)

🛑 Cas A : Refus (limite de frais dépassée)

✅ Cas B : approbation (PSBT Bitcoin autorisé)

Bitcoin, OpenSSL

Script de construction PSBT (build_psbt.py)

🛑 Cas A : Refus (limite de frais dépassée)

✅ Cas B : approbation (PSBT Bitcoin autorisé)

🕵️‍♂️ Vérifier l'état de la transaction (interrogation)

curl

B. Enregistrer la décision du signataire (autoriser)

curl

C. Récupérer la signature finale

curl

Étape 7 : Diffuser la transaction sur la blockchain

Ethereum

Dérivation et diffusion de l'identifiant de récupération

Dépannage des erreurs courantes

Bitcoin

Assemblage et diffusion des transactions SegWit Wire

Dépannage des erreurs courantes

📖 Annexe : Guide opérationnel (interrogation et inspection)

🏢 1. Instances

A. Lister toutes les instances

curl

B. Obtenir les détails d'une instance spécifique

curl

Guide de l'utilisateur sur le calcul multipartite

Script de dérivation d'adresse (`derive_address.py`)

Script de dérivation d'adresse (`derive_btc_address.py`)

Script de construction PSBT (`build_psbt.py`)

Script de construction PSBT (`build_psbt.py`)