Calling Contracts

npm install @aeternity/aepp-sdk bignumber.js

contracts/
  AffiliationBondingCurveTokenSale.aci.json
  BondingCurve.aci.json
  BondingCurveExponential.aci.json
  CommunityFactory.aci.json
  FungibleTokenFull.aci.json
  PollACI.json
  RegistryWithEventsACI.json
  Tipping_v3.aci.json

#!/usr/bin/env node
import {
  AeSdk, Node, MemoryAccount, Contract,
  formatAmount, AE_AMOUNT_FORMATS,
} from '@aeternity/aepp-sdk';
import BigNumber from 'bignumber.js';
import fs from 'fs';
 
const NODE_URL = 'https://mainnet.aeternity.io';
const SLIPPAGE_PERCENT = 3;
 
// --- 1. Account from a secret key -----------------------------------------
// AE_PRIVATE_KEY is an sk_... secret key. Never hardcode it.
const secretKey = process.env.AE_PRIVATE_KEY;
if (!secretKey) throw new Error('AE_PRIVATE_KEY is not set');
const account = new MemoryAccount(secretKey);
 
// --- 2. Node connection ----------------------------------------------------
const aeSdk = new AeSdk({
  nodes: [{ name: 'mainnet', instance: new Node(NODE_URL) }],
  accounts: [account],
});
 
// --- 3. Contract instances from ACI + address ------------------------------
const saleAddress = process.argv[2];
const sale = await Contract.initialize({
  aci: JSON.parse(fs.readFileSync('./contracts/AffiliationBondingCurveTokenSale.aci.json', 'utf8')),
  address: saleAddress,
  onAccount: aeSdk,
  onNode: aeSdk.api,
});
 
// --- 4. Read calls (free, no transaction) ----------------------------------
const tokenAddress = await sale.token_contract().then((r) => r.decodedResult);
const token = await Contract.initialize({
  aci: JSON.parse(fs.readFileSync('./contracts/FungibleTokenFull.aci.json', 'utf8')),
  address: tokenAddress,
  onAccount: aeSdk,
  onNode: aeSdk.api,
});
const meta = await token.meta_info().then((r) => r.decodedResult);
// meta = { name, symbol, decimals } — community tokens use 18 decimals.
 
// `count` is always in the token's smallest unit. 5 whole tokens at 18 decimals:
const count = new BigNumber(5).shiftedBy(Number(meta.decimals)).toFixed(0);
 
// `price(count)` quotes the buy without sending a transaction.
const priceAettos = await sale.price(count).then((r) => r.decodedResult);
console.log('price:', formatAmount(priceAettos.toString(), {
  denomination: AE_AMOUNT_FORMATS.AETTOS,
  targetDenomination: AE_AMOUNT_FORMATS.AE,
}), 'AE');
 
// --- 5. A payable write call ----------------------------------------------
// `buy` is payable: the AE goes in the `amount` option, not in an argument.
// Send a slippage buffer — the price moves with every other buy in the block.
const amount = new BigNumber(priceAettos.toString())
  .times(1 + SLIPPAGE_PERCENT / 100)
  .toFixed(0, BigNumber.ROUND_CEIL);
 
const result = await sale.buy(count, { amount, omitUnknown: true });
 
console.log('tx:', result.hash);
console.log('events:', result.decodedEvents.map((e) => e.name));

await dao.add_vote(
  {
    subject: { VotePayout: ['ak_recipient...'] },
    description: 'Pay the treasury out to the community wallet',
    link: 'https://superhero.com/trends/daos',
  },
  { amount: (555n * 10n ** 18n).toString() },
);

// What would this sell return, and would it revert?
const dry = await sale.sell(count, 0, { callStatic: true });
console.log(dry.decodedResult);        // the return value
console.log(dry.decodedEvents);        // Sell, Burn, PriceChange
console.log(dry.result.gasUsed);       // measured gas

const dry = await sale.buy(count, { amount, callStatic: true });
const gasLimit = Math.ceil(Number(dry.result.gasUsed) * 1.3);
 
await sale.buy(count, { amount, gasLimit, omitUnknown: true });

const result = await sale.buy(count, { amount, omitUnknown: true });
 
for (const e of result.decodedEvents) {
  console.log(e.name, e.contract.address, e.args);
}
// Buy         ct_sale...   [ total_price, affiliation_amount, total_supply ]
// Mint        ct_token...  [ buyer, amount ]
// Mint        ct_dao...    [ buyer, protocol_dao_amount ]
// PriceChange ct_sale...   [ previous_price, next_price ]

const tokenMint = result.decodedEvents.find(
  (e) => e.name === 'Mint' && e.contract.address === tokenAddress,
);
const protocolMint = result.decodedEvents.find(
  (e) => e.name === 'Mint' && e.contract.address !== tokenAddress,
);

try {
  await sale.sell(count, minReturn, { omitUnknown: true });
} catch (error) {
  // error.message contains the abort string, e.g. "MINIMAL_RETURN_NOT_MEET"
  console.error(error.message);
}

const forAccount = saleAddress.replaceAll('ct_', 'ak_');
 
const existing = await token
  .allowance({ from_account: aeSdk.address, for_account: forAccount })
  .then((r) => r.decodedResult)
  .catch(() => undefined);
 
if (existing === undefined) {
  await token.create_allowance(forAccount, count);
} else {
  const change = new BigNumber(count).minus(existing.toString()).toFixed();
  await token.change_allowance(forAccount, change);
}
 
await sale.sell(count, minReturn, { omitUnknown: true });

const aeSdk = new AeSdk({
  nodes: [{ name: 'mainnet', instance: new Node('https://mainnet.aeternity.io') }],
});
 
const factory = await Contract.initialize({
  aci: factoryAci,
  address: factoryAddress,
  onNode: aeSdk.api,   // no onAccount
});
 
await factory.has_community(collectionId, 'MYTOKEN');