Errors

import { AuraErrorCode, isAuraError, getAuraErrorCode } from '@aura-protocol/sdk-ts';

import { AuraClient, AuraErrorCode, isAuraError, getAuraErrorCode } from '@aura-protocol/sdk-ts';
import BN from 'bn.js';

const client = new AuraClient({ connection });
const now = new BN(Math.floor(Date.now() / 1000));

try {
  await client.proposeTransaction(
    aiAuthority,
    { aiAuthority: aiAuthority.publicKey, treasury },
    {
      amountUsd: new BN(250),
      targetChain: 2,
      txType: 0,
      protocolId: null,
      currentTimestamp: now,
      expectedOutputUsd: null,
      actualOutputUsd: null,
      quoteAgeSecs: null,
      counterpartyRiskScore: 15,
      recipientOrContract: '0xdeadbeef...',
      sanctionsProof: [],
    },
  );
} catch (err) {
  const code = getAuraErrorCode(err);
  if (code !== null) {
    switch (code) {
      case AuraErrorCode.ExecutionPaused:
        console.error('Treasury is paused — resume before proposing');
        break;
      case AuraErrorCode.PendingTransactionExists:
        console.error('Resolve the existing pending proposal first');
        break;
      case AuraErrorCode.UnauthorizedAi:
        console.error('Wrong AI authority signer');
        break;
      case AuraErrorCode.SanctionedAddress:
        console.error('Recipient is on the sanctions list');
        break;
      default:
        console.error('Program error code:', code);
    }
  } else {
    throw err;
  }
}

import { isAuraError, AuraErrorCode } from '@aura-protocol/sdk-ts';

try {
  await client.pauseExecution(owner, { owner: owner.publicKey, treasury }, true, now);
} catch (err) {
  if (isAuraError(err, AuraErrorCode.UnauthorizedOwner)) {
    console.error('Only the treasury owner can pause execution');
  } else {
    throw err;
  }
}

import { getAuraErrorCode } from '@aura-protocol/sdk-ts';

const code = getAuraErrorCode(err);
if (code !== null) {
  console.log('AURA error code:', code);
}

import { Transaction } from '@solana/web3.js';
import BN from 'bn.js';

const now = new BN(Math.floor(Date.now() / 1000));

const { treasury, instruction } = await client.createTreasuryInstruction({
  owner: owner.publicKey,
  args,
});

const tx = new Transaction().add(instruction);
tx.feePayer = owner.publicKey;
tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;

const simResult = await connection.simulateTransaction(tx);
if (simResult.value.err) {
  console.error('Simulation failed:', simResult.value.logs);
}