TxBuilder

import { TxBuilder } from "@chipi-stack/core";
import type { Account } from "starknet";

const result = await new TxBuilder(account)
  .approve(tokenAddr, spenderAddr, amount)
  .transfer(tokenAddr, [{ to: recipient, amount: 1_000_000n }])
  .send();

console.log(result.transaction_hash);

new TxBuilder(account: Account, opts?: { paymaster?: PaymasterAdapter })

builder.add({
  contractAddress: "0x...",
  entrypoint: "swap",
  calldata: [tokenIn, tokenOut, amountIn, "0"],
});

// Or add multiple at once
builder.add([call1, call2, call3]);

builder.approve(USDC_ADDRESS, DEX_ADDRESS, 1_000_000n);

builder.transfer(USDC_ADDRESS, [
  { to: "0xalice...", amount: 500_000n },
  { to: "0xbob...", amount: 300_000n },
]);

const currentCalls = builder.calls();
console.log(`${currentCalls.length} calls queued`);

const result = await builder.send();
console.log(result.transaction_hash);

const txHash = await builder.sendSponsored();
console.log(txHash); // "0x..."

const fee = await builder.estimateFee();
console.log(`Estimated fee: ${fee.overall_fee} wei`);

const sim = await builder.preflight();
console.log(`Would cost: ${sim.fee_estimation.overall_fee} wei`);

const result = await new TxBuilder(account)
  .transfer(USDC_ADDRESS, [{ to: recipient, amount: 1_500_000n }])
  .send();

const result = await new TxBuilder(account)
  .approve(USDC_ADDRESS, DEX_ADDRESS, 1_000_000n)
  .add({
    contractAddress: DEX_ADDRESS,
    entrypoint: "swap",
    calldata: [USDC_ADDRESS, ETH_ADDRESS, "1000000", "0"],
  })
  .send();

const builder = new TxBuilder(account)
  .transfer(USDC_ADDRESS, [{ to, amount }]);

const fee = await builder.estimateFee();
console.log(`This will cost: ${fee.overall_fee} wei`);

// User confirms, create new builder to send
const result = await new TxBuilder(account)
  .transfer(USDC_ADDRESS, [{ to, amount }])
  .send();

import { TxBuilder, Erc20, Amount, TokenRegistry } from "@chipi-stack/core";

const registry = new TokenRegistry("mainnet");
const usdcInfo = registry.bySymbol("USDC")!;
const usdc = new Erc20(usdcInfo, account);
const amount = Amount.parse("50.0", usdcInfo);

const result = await new TxBuilder(account)
  .add(usdc.approveCall(spender, amount))
  .add(usdc.transferCall(recipient, amount))
  .send();

import { RpcProvider, WalletAccount } from "starknet";
import { TxBuilder } from "@chipi-stack/core";

declare const USDC: string;
declare const recipient: string;

const bramble = (window as unknown as { starknet_bramble?: WalletAccount["walletProvider"] })
  .starknet_bramble;
if (!bramble) throw new Error("Bramble is not installed");

// From a click: Bramble opens its panel only during a user gesture.
// connect() sends wallet_requestAccounts with { silent_mode: false }.
const account = await WalletAccount.connect(
  new RpcProvider({ nodeUrl: "https://api.cartridge.gg/x/starknet/mainnet" }),
  bramble
);

// send() calls wallet_addInvokeTransaction with { calls } and nothing else.
// Bramble estimates the fee, the user approves it, and the account pays in STRK.
const { transaction_hash } = await new TxBuilder(account)
  .transfer(USDC, [{ to: recipient, amount: 1_000_000n }])
  .send();

import Controller from "@cartridge/controller";
import { TxBuilder } from "@chipi-stack/core";
import { ChipiBrowserSDK } from "@chipi-stack/backend";

const controller = new Controller();
await controller.connect();

const sdk = new ChipiBrowserSDK({ apiPublicKey: "pk_..." });
const paymaster = sdk.createPaymasterAdapter(userBearerToken);

// controller IS Account-compatible
const txHash = await new TxBuilder(controller, { paymaster })
  .transfer(USDC, [{ to, amount }])
  .sendSponsored();

import { createAccount, DirectSigner, TxBuilder } from "@chipi-stack/core";
import { ChipiServerSDK } from "@chipi-stack/backend";

const sdk = new ChipiServerSDK({ apiPublicKey: "pk_...", apiSecretKey: "sk_..." });
const paymaster = sdk.createPaymasterAdapter();

const provider = { nodeUrl: "https://starknet-mainnet.infura.io/v3/YOUR_KEY" };
const accountAddress = "0xYOUR_ACCOUNT_ADDRESS";
const signer = new DirectSigner(process.env.AUTOMATION_KEY!, accountAddress);
const account = await createAccount({ signer, provider });

const txHash = await new TxBuilder(account, { paymaster })
  .approve(USDC, spender, amount)
  .transfer(USDC, [{ to, amount }])
  .sendSponsored(); // gasless, no popup