Docs | Magic Newton Foundation

This section will help you get started with running a verified transaction using the Newton network. For this example we will use an existing policy that checks whether the transaction is being sent to a sanctioned address. If it is not sanctioned, the transaction is permitted. Here the policy and the policy client is already deployed to Newton and Ethereum Sepolia respectively. We will submit a task to the Newton protocol, then a transaction to Ethereum mainnet execute the compliant transaction. See here if you want to write your own policy.

Set up

In order to run verified transactions, you must first set up a policy and policy client. For the purposes of the quickstart, these two have already been written and deployed. See below for details on how they work

Show Policy

PolicyThe below contains the policy code that we will use for this example. This is written in a language called rego, see here for how to write your own policy code.

The policy code for this example has already been deployed and uploaded to IPFS and a pointer is stored on Ethereum here. No action is required

# Chainalysis Sanctions Policy
# --------------------------------

package chainalysis_sanctions_agent

# By default, deny requests.
default allow := false

# From Intent
to_address := input.to

# From Policy Data
api_call_status := data.data.status
checked_address := data.data.address
is_sanctioned := data.data.sanctioned

# Allow the action if the `to` address is not sanctioned
allow if {
    api_call_status == 200
    checked_address == to_address
    not is_sanctioned
}

The policy returns true if the API call to Chainalysis with the address returned is not sanctioned. The next section will show how this API call is made via the policy data oracle.Third party offchain data can be executed as part of a policy. The below shows the source code for the data oracle that is pulled from Chainalysis for the policy outlined in the previous section.See here if you want to write your own data oracle.

The following data oracle is already deployed. No action is required

import { fetch as httpFetch } from 'newton:provider/[email protected]';

export function run(address) {
  const response = httpFetch({
    url: `https://o66wu5mr47.execute-api.us-east-2.amazonaws.com/default/chainalysis/address/${address}`,
    method: "GET",
    headers: [],
    body: null
  });
  
  const body = JSON.parse(new TextDecoder().decode(new Uint8Array(response.body)));
  
  return JSON.stringify({ 
    status: response.status,
    address,
    sanctioned: body.identifications.length > 0,
    identifications: body.identifications,
  });
}

Here the Chainlysis endpoint for sanctions screenining is checked, see here for more details about the endpoint.

Show Policy client

The following shows a smart contract that has implemented the above policy. This is known in the Newton protocol as a policy client. This particular example can be found on Ethereum Sepolia here.Note that the method sanctionProtectedTransfercontains a require condition that enforces the Newton policy. A proof must be provided when using this smart contract else the method will fail.

This policy has been deployed and is located here on Eth Sepolia. No action is required

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {NewtonPolicyClient} from "@newton/contracts/src/mixins/NewtonPolicyClient.sol";
import {INewtonPolicy} from "@newton/contracts/src/interfaces/INewtonPolicy.sol";
import {NewtonMessage} from "@newton/contracts/src/core/NewtonMessage.sol";

contract YourVault is NewtonPolicyClient {
    event Success();

    error InvalidAttestation();
    error TransferFailed();
	
    // since the factory is used to clone the client, the constructor doesn't need to do anything
    constructor() {}

    // this is called by the deploy script
    function initialize(
        address policyTaskManager,
        address policy, //refers to the policy address
        address owner
    ) external {
        _initNewtonPolicyClient(policyTaskManager, policy, owner);
    }
	
    // this function duplicates the functionality the base NewtonPolicyClient without permissioning
    // don't do this in production
	function setParameters(INewtonPolicy.PolicyConfig memory _config) external {
        _setPolicy(_config);
    }
  
    // this is the policy guarded function
    function sanctionProtectedTransfer(NewtonMessage.Attestation memory attestation) external payable {
        require(_validateAttestation(attestation), InvalidAttestation());

        // Your function's business logic goes here

        // Extract recipient and value from the attestation intent
        address recipient = attestation.intent.to;
        uint256 amount = attestation.intent.value;

        // Transfer ETH to the recipient
        (bool success, ) = recipient.call{value: amount}("");
        require(success, TransferFailed());

        emit Success();
    }
}

Verify intent

Now that a policy is deployed and ready we can submit a transaction against it. But first a proof needs to be generated. To do that, we will submit a task to the Newton protocol which will return the proof. Before proceeding, ensure that you install the newton-protocol-sdk

npm install @magicnewton/newton-protocol-sdk

Note the public address of your PRIVATE_KEY needs to be allowlisted by the Newton team before proceeding with this step.

import { privateKeyToAccount } from "viem/accounts";
import {
  createWalletClient,
  createPublicClient,
  publicActions,
  webSocket,
} from "viem";
import { sepolia } from "viem/chains";
import {
  newtonWalletClientActions,
  newtonPublicClientActions,
} from "@magicnewton/newton-protocol-sdk";

const signer = privateKeyToAccount(PRIVATE_KEY);

export const walletClient = createWalletClient({
  chain: sepolia,
  transport: webSocket(webSocketUrl),
  account: signer,
})
  .extend(publicActions)
  .extend(newtonWalletClientActions());

const publicClient = createPublicClient({
  chain: sepolia,
  transport: webSocket(webSocketUrl),
}).extend(
  newtonPublicClientActions({
    policyContractAddress: POLICY_CLIENT_ADDRESS,
  })
);

function stringToHexBytes(str: string) {
  const encoder = new TextEncoder();
  const bytes = encoder.encode(str);
  return Array.from(bytes)
    .map((byte) => byte.toString(16).padStart(2, "0"))
    .join("");
}

const wasmArgs = stringToHexBytes(toAddress);

const intentCode = `{
  "policyClient": "${POLICY_CLIENT_ADDRESS}",
  "intent": {
      "from": "${connectedAddress}",
      "to": "${toAddress}",
      "value": "0x1",
      "data": "0x",
      "chainId": 11155111,
      "functionSignature": "0x"
  },
  "timeout": 60,
  "wasmArgs": "${wasmArgs}"
}`;

const pendingTask = await walletClient.submitEvaluationRequest(
  JSON.parse(intentCode)
);

const response: TaskResponseResult = await publicClient.waitForTaskResponded({
  taskId: pendingTask.result.taskId,
  timeoutMs: 20_000,
});

console.log("evaluation result: ", response.taskResponse.evaluationResult);
console.log("attestation: ", response.attestation);

Execute intent

At this point we have a proof that be used execute the transaction. The following code submits a transaction with the proof using viem.

import { createPublicClient, custom, walletActions } from "viem";

const browserWalletClient = createWalletClient({
  chain: sepolia,
  transport: custom(window.ethereum),
}).extend(walletActions);

console.log("Submitting transaction with attestation:", attestation);

// Submit the transaction
const hash = await browserWalletClient.writeContract({
  address: POLICY_CLIENT_ADDRESS as `0x${string}`,
  abi: POLICY_CLIENT_ABI,
  functionName: "sanctionProtectedTransfer",
  args: [attestation],
  account: connectedAddress as `0x${string}`,
});

console.log("Transaction submitted:", hash);

The transaction should go through. We have demonstrated how a transaction can be validated against offchain data in a policy and enforced by the Newton protocol.

Overview

Reference

Advanced

Quickstart

Set up

Verify intent

Execute intent

Overview

Reference

Advanced

​Set up

​Verify intent

​Execute intent

Set up

Verify intent

Execute intent