TypeScript 智能合约：合约逻辑类型实现

            
interface User {
  id: number;
  name: string;
  balance: number;
  countryCode: string; // ISO 3166-1 alpha-2 country code
}

type Product = {
  productId: string;
  name: string;
  price: number;
  description: string;
  manufacturer: string;
  originCountry: string; // ISO 3166-1 alpha-2 country code
};

            

              
                Copy
              
            
          

            
function transferFunds(from: string, to: string, amount: number): boolean {
  // Implementation
  return true; // Or false based on success
}

            

              
                Copy
              
            
          

            
enum ContractState {
  Pending,
  Active,
  Paused,
  Completed,
  Cancelled,
}

let currentState: ContractState = ContractState.Pending;

function activateContract(): void {
  if (currentState === ContractState.Pending) {
    currentState = ContractState.Active;
  }
}

            

              
                Copy
              
            
          

            
function wrapInArray<T>(item: T): T[] {
  return [item];
}

const numberArray = wrapInArray(123); // numberArray is of type number[]
const stringArray = wrapInArray("hello"); // stringArray is of type string[]

            

              
                Copy
              
            
          

            
type StringOrNumber = string | number;

function printValue(value: StringOrNumber): void {
  console.log(value);
}

printValue("Hello"); // Valid
printValue(123); // Valid

            

              
                Copy
              
            
          

            
interface UserProfile {
    username: string;
    email: string;
    country: string; // ISO 3166-1 alpha-2 code
}

const userProfiles: { [address: string]: UserProfile } = {};

function createUserProfile(address: string, profile: UserProfile): void {
    userProfiles[address] = profile;
}

function getUserProfile(address: string): UserProfile | undefined {
    return userProfiles[address];
}

// Usage
createUserProfile("0x123abc", { username: "johndoe", email: "john@example.com", country: "US" });
const profile = getUserProfile("0x123abc");
if (profile) {
    console.log(profile.username);
}

            

              
                Copy
              
            
          

            
enum UserRole {
  Admin,
  AuthorizedUser,
  ReadOnly
}

let userRoles: { [address: string]: UserRole } = {};

function requireRole(role: UserRole, address: string): void {
  if (userRoles[address] !== role) {
    throw new Error("Insufficient permissions");
  }
}

function setPrice(newPrice: number, sender: string): void {
  requireRole(UserRole.Admin, sender);
  // Implementation
}

            

              
                Copy
              
            
          

            
let circuitBreakerEnabled: boolean = false;

function toggleCircuitBreaker(sender: string): void {
  requireRole(UserRole.Admin, sender);
  circuitBreakerEnabled = !circuitBreakerEnabled;
}

function sensitiveFunction(): void {
  if (circuitBreakerEnabled) {
    throw new Error("Circuit breaker is enabled");
  }
  // Implementation
}

            

              
                Copy
              
            
          

            
let balances: { [address: string]: number } = {};

function deposit(sender: string, amount: number): void {
  balances[sender] = (balances[sender] || 0) + amount;
}

function withdraw(recipient: string, amount: number): void {
  if (balances[recipient] === undefined || balances[recipient] < amount) {
    throw new Error("Insufficient balance");
  }
  balances[recipient] -= amount;
  // Transfer funds to recipient (implementation depends on the specific blockchain)
  console.log(`Transferred ${amount} to ${recipient}`);
}

            

              
                Copy
              
            
          

            
interface Product {
    id: string; // Unique product ID
    name: string;
    description: string;
    price: number; // Price in USD (for simplicity)
    sellerAddress: string;
    availableQuantity: number;
    originCountry: string; // ISO 3166-1 alpha-2
}

let products: { [id: string]: Product } = {};

function addProduct(product: Product, sender: string): void {
    // Access control: Only seller can add the product
    if (product.sellerAddress !== sender) {
        throw new Error("Only the seller can add this product.");
    }
    if (products[product.id]) {
      throw new Error("Product with this ID already exists");
    }
    products[product.id] = product;
}

function purchaseProduct(productId: string, quantity: number, buyerAddress: string): void {
    const product = products[productId];
    if (!product) {
        throw new Error("Product not found.");
    }
    if (product.availableQuantity < quantity) {
        throw new Error("Insufficient stock.");
    }

    // Simulate payment (replace with actual payment gateway integration)
    console.log(`Payment of ${product.price * quantity} USD received from ${buyerAddress}.`);

    product.availableQuantity -= quantity;

    // Handle transfer of ownership, shipping, etc.
    console.log(`Product ${productId} purchased by ${buyerAddress}. Origin: ${product.originCountry}`);
}

function getProductDetails(productId: string): Product | undefined {
  return products[productId];
}

            

              
                Copy