This guide demonstrates how to create, sign, and broadcast a transaction using the Adamik API with StarkNet. This tutorial is perfect for developers who want to leverage Adamik to power their StarkNet workflow, ensuring secure and efficient transaction management.

​
Prerequisites

  • Node.js and npm installed
  • Basic understanding of StarkNet blockchain and transaction workflows
  • Familiarity with StarkNet libraries

​
Step-by-Step Guide

​
1. Setting Up the Environment

Install the required dependencies:

npm install starknet

​
2. Writing the Script

Below is the script that handles StarkNet transactions, including wallet deployment and transfers:

You can find the complete code example in the Adamik GitHub repository.

import { ec } from "starknet";

// Replace with your StarkNet private key
const walletPrivateKey = "your-starknet-private-key";
// Replace with your Adamik API key from https://dashboard.adamik.io
const ADAMIK_API_KEY = "your-adamik-api-key";

async function main() {
  try {
    console.log("Creating wallet...");
    const pubKey = ec.starkCurve.getStarkKey(walletPrivateKey);

    // First, let's get our wallet address
    const requestBodyAddressEncode = {
      pubkey: pubKey,
    };

    // Fetch the wallet address from Adamik API
    const responseAddressEncode = await fetch(
      "https://api.adamik.io/api/starknet/address/encode",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: ADAMIK_API_KEY,
        },
        body: JSON.stringify(requestBodyAddressEncode),
      }
    );

    const addressEncode = await responseAddressEncode.json();
    // Get the ArgentX wallet address
    const senderAddress = addressEncode.addresses.find(
      (address) => address.type === "argentx"
    ).address;

    console.log("Sender address:", senderAddress);

    // Prepare the transfer transaction
    const requestBody = {
      transaction: {
        data: {
          mode: "transfer", // Transaction type
          senderAddress, // Our wallet address
          recipientAddress: senderAddress, // Where we're sending to (self-transfer in this example)
          amount: "20000000000", // Amount in wei (0.00002 STRK in this example)
        },
      },
    };

    console.log("Encoding transaction...");
    const response = await fetch(
      "https://api.adamik.io/api/starknet/transaction/encode",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: ADAMIK_API_KEY,
        },
        body: JSON.stringify(requestBody),
      }
    );

    let encodedData = await response.json();

    // Check for encoding errors
    if (
      encodedData.status &&
      encodedData.status.errors &&
      encodedData.status.errors.length > 0
    ) {
      if (
        encodedData.status.errors[0].message === "Sender account does not exist"
      ) {
        console.log(
          "Account never deployed... Creating deployment transaction"
        );
        // We need to deploy the account because it hasn't been deployed yet
        const requestBodyDeploy = {
          transaction: {
            data: {
              mode: "deployAccount", // Transaction type
              senderPubKey: pubKey,
              type: "argentx",
            },
          },
        };

        console.log("Encoding deployment transaction...");
        const responseDeploy = await fetch(
          "https://api.adamik.io/api/starknet/transaction/encode",
          {
            method: "POST",
            headers: {
              "Content-Type": "application/json",
              Authorization: ADAMIK_API_KEY,
            },
            body: JSON.stringify(requestBodyDeploy),
          }
        );
        encodedData = await responseDeploy.json();

        console.log(
          "Deployment transaction encoded:",
          JSON.stringify(encodedData, null, 2)
        );
      } else {
        throw new Error(encodedData.status.errors[0].message);
      }
    }

    console.log("Signing transaction...");
    // Sign the encoded transaction using StarkNet curve
    const signature = ec.starkCurve.sign(
      encodedData.transaction.encoded,
      walletPrivateKey
    );
    const signatureHex = signature.toDERHex();

    console.log("Transaction signed");

    // Prepare the broadcast request
    const broadcastTransactionBody = {
      transaction: {
        ...encodedData.transaction,
        signature: signatureHex,
      },
    };

    console.log("Broadcasting transaction...");
    // Broadcast the signed transaction
    const broadcastResponse = await fetch(
      "https://api.adamik.io/api/starknet/transaction/broadcast",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: ADAMIK_API_KEY,
        },
        body: JSON.stringify(broadcastTransactionBody),
      }
    );

    const responseData = await broadcastResponse.json();
    console.log("Transaction Result:", JSON.stringify(responseData, null, 2));
    console.log("Transaction hash:", responseData.hash);
  } catch (error) {
    console.error("Error:", error);
  }
}

main();

​
3. Explanation

  • Key Generation: The script uses the StarkNet curve to generate a public key from your private key.
  • Address Encoding: Before making a transfer, we need to get our wallet address using the Adamik API’s address encode endpoint.
  • Transaction Encoding: The transaction details are passed to the Adamik API, which encodes the transaction specifically for StarkNet.
  • Signing: The encoded transaction is signed using StarkNet’s signature scheme.
  • Broadcasting: The signed transaction is broadcast to the StarkNet network via the Adamik API.
  • Account Deployment: The script also handles the case where the account hasn’t been deployed yet, automatically creating a deployment transaction if needed.

​
4. Troubleshooting

  • Invalid Signature: Ensure you’re using the correct private key and StarkNet curve for signing.
  • Gas Fees: Make sure your wallet has enough funds to cover gas fees.

​
5. Get in Touch

Connect with us through our Discord Server or directly through GitHub.

Was this page helpful?

Raise issue