TokenFactory: Deploy RWA Tokens from Pre-Audited Templates

import { TokenFactory } from "@ankarachain/sdk";
import { ethers } from "ethers"; // EVM only

new TokenFactory(config: AnkaraChainConfig)

import { TokenFactory } from "@ankarachain/sdk";
import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://rpc-amoy.polygon.technology");
const signer   = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

const factory = new TokenFactory({
  network: "polygon-amoy",
  signer,
});

import { TokenFactory } from "@ankarachain/sdk";

const factory = new TokenFactory({
  network: "stellar-testnet",
  stellarSecretKey: process.env.STELLAR_SECRET!, // server-side only
});

import { TokenFactory } from "@ankarachain/sdk";
import freighter from "@stellar/freighter-api";

const factory = new TokenFactory({
  network: "stellar-testnet",
  stellarSigner: {
    publicKey: await freighter.getPublicKey(),
    signTransaction: freighter.signTransaction,
  },
});

deployFarmland(opts: DeployFarmlandOptions): Promise<DeployResult>

import { TokenFactory } from "@ankarachain/sdk";
import { ethers } from "ethers";

const factory = new TokenFactory({ network: "polygon-amoy", signer });

const result = await factory.deployFarmland({
  name:        "Kano Farmland Token",
  symbol:      "KFT",
  assetId:     "KANO-FARM-001",
  countryCode: "NG",
  metadata: {
    location:          "Kano State, Nigeria — Plot 14B, Dawanau",
    areaSqMeters:      250_000n,
    soilType:          "Sandy loam",
    irrigationType:    "Drip",
    cropHistory:       "Sesame (2022), Soybean (2023), Sorghum (2024)",
    titleDocumentHash: "0xabc123...def456",  // bytes32 hex
    valuationUSD:      150_000n * 10n ** 18n, // $150,000 in wei
    stateRegion:       "Kano",
    lastUpdated:       BigInt(Math.floor(Date.now() / 1000)),
  },
});

console.log("Token deployed at:", result.tokenAddress);
console.log("Transaction hash:", result.txHash);

deployCommodity(opts: DeployCommodityOptions): Promise<DeployResult>

const result = await factory.deployCommodity({
  name:        "Lagos Cocoa Receipt",
  symbol:      "LCR",
  assetId:     "LAGOS-COCOA-2024-001",
  countryCode: "NG",
  metadata: {
    commodityType:        "Cocoa",
    quantityKg:           50_000n,
    gradeClassification:  "Grade A",
    warehouseId:          "WH-APAPA-003",
    warehouseLocation:    "Apapa, Lagos",
    depositDate:          BigInt(Math.floor(Date.now() / 1000)),
    expiryDate:           BigInt(Math.floor(Date.now() / 1000) + 60 * 24 * 60 * 60),
    inspectionReportHash: "0xdeadbeef...",
    valuationUSD:         75_000n * 10n ** 18n,
    harvestSeason:        "2024A",
    lastUpdated:          BigInt(Math.floor(Date.now() / 1000)),
  },
});

deployRealEstate(opts: DeployRealEstateOptions): Promise<DeployResult>

deployInvoice(opts: DeployInvoiceOptions): Promise<DeployResult>

deployCarbonCredit(opts: DeployCarbonCreditOptions): Promise<DeployResult>

deployMiningRights(opts: DeployMiningRightsOptions): Promise<DeployResult>

deployFarmlandNFT(opts: DeployFarmlandNFTOptions): Promise<NFTDeployResult>

deployRealEstateNFT(opts: DeployRealEstateNFTOptions): Promise<NFTDeployResult>

deployMiningRightsNFT(opts: DeployMiningRightsNFTOptions): Promise<NFTDeployResult>

deployCommodityVaultNFT(opts: DeployCommodityVaultNFTOptions): Promise<NFTDeployResult>

const nfts  = await factory.getDeployedNFTs();       // defaults to connected signer
const count = await factory.totalDeployedNFTs();

deployCommodityBatchToken(opts: DeployCommodityBatchOptions): Promise<MultiTokenDeployResult>

deployPoolVault(opts: DeployPoolVaultOptions): Promise<MultiTokenDeployResult>

deployEscrow(opts: DeployEscrowOptions): Promise<EscrowDeployResult>

const escrowResult = await factory.deployEscrow({
  payer:    "0xPayerAddress",
  payee:    "0xPayeeAddress",
  token:    "0xUSDCAddress",
  milestones: [
    { amount: ethers.parseUnits("5000", 6) },
    { amount: ethers.parseUnits("5000", 6), descriptionHash: "0xabc..." },
    { amount: ethers.parseUnits("10000", 6) },
  ],
  arbiter:                "0xArbitratorAddress",
  timelockDurationSeconds: 7 * 24 * 60 * 60,
});

console.log("Escrow at:", escrowResult.escrowAddress);

deployRampSettlement(opts: DeployRampSettlementOptions): Promise<RampSettlementDeployResult>

// ERC-20 tokens
const tokens = await factory.getDeployedTokens();        // defaults to connected signer
const total  = await factory.totalDeployed();

// NFTs
const nfts      = await factory.getDeployedNFTs();
const nftCount  = await factory.totalDeployedNFTs();

// Escrows
const escrows      = await factory.getDeployedEscrows();
const escrowCount  = await factory.totalDeployedEscrows();

// Multi-tokens
const multiTokens = await factory.getDeployedMultiTokens();
const mtCount     = await factory.totalDeployedMultiTokens();

// Ramp settlements
const ramps     = await factory.getDeployedRampSettlements();
const rampCount = await factory.totalDeployedRampSettlements();

// Native balance (MATIC / ETH / BNB / XLM)
const balance = await factory.getBalance();

factory.adapter  // The underlying IAdapter (EVMAdapter or StellarAdapter)
factory.network  // The SupportedNetwork string passed to the constructor

type EVMSupportedNetwork =
  | "polygon" | "polygon-amoy" | "ethereum"
  | "bnb" | "celo" | "localhost";

type StellarSupportedNetwork = "stellar" | "stellar-testnet";

type SupportedNetwork = EVMSupportedNetwork | StellarSupportedNetwork;

interface EVMAnkaraChainConfig {
  network: EVMSupportedNetwork;
  signer?: ethers.Signer;
  provider?: ethers.Provider;
  factoryAddress?: string;
  nftFactoryAddress?: string;
  escrowFactoryAddress?: string;
  multiTokenFactoryAddress?: string;
  rampSettlementFactoryAddress?: string;
  rpcUrl?: string;
}

interface StellarAnkaraChainConfig {
  network: StellarSupportedNetwork;
  stellarSecretKey?: string;
  stellarSigner?: StellarExternalSigner;
  factoryAddress?: string;
  nftFactoryAddress?: string;
  escrowFactoryAddress?: string;
  multiTokenFactoryAddress?: string;
  rampSettlementFactoryAddress?: string;
  rpcUrl?: string;
}

interface DeployResult {
  tokenAddress: string;
  txHash: string;
  assetId: string;
  template: AssetTemplate;
  network: SupportedNetwork;
  deployedAt: number;
}