@rozoai/intent-common 0.0.32-beta.1 → 0.0.32-beta.2

package/src/token.ts

@@ -2,10 +2,12 @@ import { Address, getAddress, zeroAddress } from "viem";
 import { assertNotNull } from "./assert";
 import {
   arbitrum,
+  avalanche,
   base,
   bsc,
   celo,
   ethereum,
+  gnosis,
   linea,
   mantle,
   optimism,
@@ -716,11 +718,22 @@ export const rozoSolanaUSDC: Token = token({
   logoURI: TokenLogo.USDC,
 });
 
+export const rozoSolanaUSDT: Token = token({
+  chainId: rozoSolana.chainId,
+  token: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: TokenLogo.USDT,
+});
+
 const solanaTokens: Token[] = [
   solanaUSDC,
   solanaWSOL,
   solanaSOL,
   rozoSolanaUSDC,
+  rozoSolanaUSDT,
 ];
 
 //
@@ -748,8 +761,8 @@ export const stellarUSDC: Token = token({
 
 export const rozoStellarUSDC: Token = token({
   chainId: rozoStellar.chainId,
-  token: "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
-  decimals: 6,
+  token: "USDC:GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN",
+  decimals: 7,
   fiatISO: "USD",
   name: "USD Coin",
   symbol: "USDC",
@@ -809,30 +822,109 @@ const worldchainTokens: Token[] = [
   worldchainWLD,
 ];
 
-const knownTokensByChain = new Map<number, Token[]>([
-  [arbitrum.chainId, arbitrumTokens],
-  [base.chainId, baseTokens],
-  [bsc.chainId, bscTokens],
-  [celo.chainId, celoTokens],
-  [ethereum.chainId, ethereumTokens],
-  [linea.chainId, lineaTokens],
-  [mantle.chainId, mantleTokens],
-  [optimism.chainId, optimismTokens],
-  [polygon.chainId, polygonTokens],
-  [rozoSolana.chainId, solanaTokens],
-  [rozoStellar.chainId, stellarTokens],
-  [worldchain.chainId, worldchainTokens],
+//
+// Gnosis
+//
+
+export const gnosisXDAI = nativeToken({
+  chainId: gnosis.chainId,
+  name: "xDAI",
+  symbol: "XDAI",
+  logoURI: TokenLogo.DAI,
+});
+
+export const gnosisUSDC: Token = token({
+  chainId: gnosis.chainId,
+  token: getAddress("0x2a22f9c3b484c3629090feed35f17ff8f88f76f0"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: TokenLogo.USDC,
+});
+
+export const gnosisUSDT: Token = token({
+  chainId: gnosis.chainId,
+  token: getAddress("0x4ecaba5870353805a9f068101a40e0f32ed605c6"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: TokenLogo.USDT,
+});
+
+const gnosisTokens: Token[] = [gnosisXDAI, gnosisUSDC, gnosisUSDT];
+
+//
+// Avalanche
+//
+
+export const avalancheAVAX = nativeToken({
+  chainId: avalanche.chainId,
+  name: "Avalanche",
+  symbol: "AVAX",
+  logoURI: TokenLogo.AVAX,
+});
+
+export const avalancheUSDC: Token = token({
+  chainId: avalanche.chainId,
+  token: getAddress("0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: TokenLogo.USDC,
+});
+
+export const avalancheUSDT: Token = token({
+  chainId: avalanche.chainId,
+  token: getAddress("0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: TokenLogo.USDT,
+});
+
+const avalancheTokens: Token[] = [avalancheAVAX, avalancheUSDC, avalancheUSDT];
+
+/** Support tokens for Rozo Pay */
+export const supportedTokens: Map<number, Token[]> = new Map([
+  [arbitrum.chainId, [arbitrumUSDC, arbitrumUSDT]],
+  [avalanche.chainId, [avalancheUSDC, avalancheUSDT]],
+  [base.chainId, [baseUSDC]],
+  [ethereum.chainId, [ethereumUSDC, ethereumUSDT]],
+  [gnosis.chainId, [gnosisUSDC, gnosisUSDT]],
+  [optimism.chainId, [optimismUSDC, optimismUSDT]],
+  [polygon.chainId, [polygonUSDC, polygonUSDT]],
+  [rozoSolana.chainId, [rozoSolanaUSDC, rozoSolanaUSDT]],
+  [rozoStellar.chainId, [rozoStellarUSDC]],
 ]);
 
+// const knownTokensByChain = new Map<number, Token[]>([
+//   [arbitrum.chainId, arbitrumTokens],
+//   [avalanche.chainId, avalancheTokens],
+//   [base.chainId, baseTokens],
+//   [bsc.chainId, bscTokens],
+//   [celo.chainId, celoTokens],
+//   [ethereum.chainId, ethereumTokens],
+//   [gnosis.chainId, gnosisTokens],
+//   [linea.chainId, lineaTokens],
+//   [mantle.chainId, mantleTokens],
+//   [optimism.chainId, optimismTokens],
+//   [polygon.chainId, polygonTokens],
+//   [rozoSolana.chainId, solanaTokens],
+//   [rozoStellar.chainId, stellarTokens],
+//   [worldchain.chainId, worldchainTokens],
+// ]);
+
 /**
  * Common tokens, included for convenience.
  *
  * Rozo Pay supports payment in many more tokens. In general, the goal for
  * Pay is to accept all tokens with DEX liquidity on any major chain.
  */
-export const knownTokens: Token[] = Array.from(
-  knownTokensByChain.values()
-).flat();
+export const knownTokens: Token[] = Array.from(supportedTokens.values()).flat();
 
 /* --------------------- Tokens By Address --------------------- */
 
@@ -982,6 +1074,20 @@ const tokensByChainAndType: Map<
       [TokenType.NATIVE_USDC]: rozoStellarUSDC,
     },
   ],
+  [
+    gnosis.chainId,
+    {
+      [TokenType.NATIVE]: gnosisXDAI,
+      [TokenType.NATIVE_USDC]: gnosisUSDC,
+    },
+  ],
+  [
+    avalanche.chainId,
+    {
+      [TokenType.NATIVE]: avalancheAVAX,
+      [TokenType.NATIVE_USDC]: avalancheUSDC,
+    },
+  ],
   [
     worldchain.chainId,
     {

package/src/validation.ts

@@ -0,0 +1,54 @@
+import { PublicKey } from "@solana/web3.js";
+import { Address } from "@stellar/stellar-sdk";
+import { getAddress } from "viem";
+import { Chain, supportedChains } from "./chain";
+import { getKnownToken } from "./token";
+
+// Type guards
+export function isChainSupported(
+  chainId: number,
+  type?: "evm" | "solana" | "stellar"
+): boolean {
+  return supportedChains.some(
+    (chain: Chain) =>
+      chain.chainId === chainId && (type ? chain.type === type : true)
+  );
+}
+
+export function isTokenSupported(
+  chainId: number,
+  tokenAddress: string
+): boolean {
+  return !!getKnownToken(chainId, tokenAddress);
+}
+
+// Validation helpers
+export function isValidEvmAddress(address: string): boolean {
+  return !!getAddress(address);
+}
+
+export function isValidSolanaAddress(address: string): boolean {
+  const key = new PublicKey(address);
+  return PublicKey.isOnCurve(key.toBytes());
+}
+
+export function isValidStellarAddress(address: string): boolean {
+  return !!Address.fromString(address);
+}
+
+/**
+ * Validates that an address matches the expected format for a given chain
+ */
+export function validateAddressForChain(
+  chainId: number,
+  address: string
+): boolean {
+  if (isChainSupported(chainId, "evm")) {
+    return !!getAddress(address);
+  } else if (isChainSupported(chainId, "solana")) {
+    return isValidSolanaAddress(address);
+  } else if (isChainSupported(chainId, "stellar")) {
+    return isValidStellarAddress(address);
+  }
+  return false;
+}

package/test/bridge.test.ts

@@ -0,0 +1,393 @@
+import test from "tape";
+import { createPaymentBridgeConfig, PaymentBridgeConfig } from "../src/bridge";
+import { base, polygon, rozoSolana, rozoStellar } from "../src/chain";
+import {
+  baseUSDC,
+  polygonUSDC,
+  rozoSolanaUSDC,
+  rozoStellarUSDC,
+} from "../src/token";
+
+// Valid addresses for testing
+const VALID_EVM_ADDRESS = "0x1a5FdBc891c5D4E6aD68064Ae45D43146D4F9f3a";
+const VALID_SOLANA_ADDRESS = "E35325pbtxCRsA4uVoC3cyBDZy8BMpmxvsvGcHNUa18k";
+const VALID_STELLAR_ADDRESS =
+  "GDATMUNQEPN4TPETV47LAKGJELK4DUHHDRPMGD3K5LOHUPXX2DI623KY";
+
+test("createPaymentBridgeConfig - Cross-chain payment (Polygon USDC to Base USDC)", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1", // 1 USDC
+    preferredChain: polygon.chainId,
+    preferredTokenAddress: polygonUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.preferred.preferredChain,
+    String(polygon.chainId),
+    "Preferred chain should be Polygon"
+  );
+  t.equal(
+    result.preferred.preferredToken,
+    "USDC",
+    "Preferred token should be USDC"
+  );
+  t.equal(
+    result.preferred.preferredTokenAddress,
+    polygonUSDC.token,
+    "Preferred token address should match Polygon USDC"
+  );
+
+  t.equal(
+    result.destination.chainId,
+    String(base.chainId),
+    "Destination chain should be Base"
+  );
+  t.equal(
+    result.destination.tokenSymbol,
+    "USDC",
+    "Destination token symbol should be USDC"
+  );
+  t.equal(
+    result.destination.tokenAddress,
+    baseUSDC.token,
+    "Destination token address should match Base USDC"
+  );
+  t.equal(
+    result.destination.destinationAddress,
+    VALID_EVM_ADDRESS,
+    "Destination address should match"
+  );
+  t.equal(result.destination.amountUnits, "1", "Amount units should match");
+
+  t.equal(
+    result.isIntentPayment,
+    true,
+    "Should be an intent payment (different chains)"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Same-chain payment (Base USDC to Base USDC)", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.preferred.preferredChain,
+    String(base.chainId),
+    "Preferred chain should be Base"
+  );
+  t.equal(
+    result.preferred.preferredToken,
+    "USDC",
+    "Preferred token should be USDC"
+  );
+
+  t.equal(
+    result.destination.chainId,
+    String(base.chainId),
+    "Destination chain should be Base"
+  );
+
+  t.equal(
+    result.isIntentPayment,
+    false,
+    "Should not be an intent payment (same chain and token)"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Payment to Stellar destination", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: rozoStellar.chainId,
+    toToken: rozoStellarUSDC.token,
+    toAddress: VALID_STELLAR_ADDRESS,
+    toUnits: "1", // 1 USDC
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.preferred.preferredChain,
+    String(base.chainId),
+    "Preferred chain should be Base"
+  );
+  t.equal(
+    result.preferred.preferredToken,
+    "USDC",
+    "Preferred token should be USDC"
+  );
+
+  // Destination should be configured for Stellar
+  t.equal(
+    result.destination.chainId,
+    String(rozoStellarUSDC.chainId),
+    "Destination chain should be Stellar"
+  );
+  t.equal(
+    result.destination.tokenSymbol,
+    rozoStellarUSDC.symbol,
+    "Destination token symbol should be Stellar USDC"
+  );
+  t.equal(
+    result.destination.tokenAddress,
+    rozoStellarUSDC.token,
+    "Destination token address should match Stellar USDC"
+  );
+  t.equal(
+    result.destination.destinationAddress,
+    VALID_STELLAR_ADDRESS,
+    "Destination address should match Stellar address"
+  );
+
+  t.equal(
+    result.isIntentPayment,
+    true,
+    "Should be an intent payment (Base to Stellar)"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Payment to Solana destination", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: rozoSolana.chainId,
+    toToken: rozoSolanaUSDC.token,
+    toAddress: VALID_SOLANA_ADDRESS,
+    toUnits: "1", // 1 USDC
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.preferred.preferredChain,
+    String(base.chainId),
+    "Preferred chain should be Base"
+  );
+  t.equal(
+    result.preferred.preferredToken,
+    "USDC",
+    "Preferred token should be USDC"
+  );
+
+  // Destination should be configured for Solana
+  t.equal(
+    result.destination.chainId,
+    String(rozoSolanaUSDC.chainId),
+    "Destination chain should be Solana"
+  );
+  t.equal(
+    result.destination.tokenSymbol,
+    rozoSolanaUSDC.symbol,
+    "Destination token symbol should be Solana USDC"
+  );
+  t.equal(
+    result.destination.tokenAddress,
+    rozoSolanaUSDC.token,
+    "Destination token address should match Solana USDC"
+  );
+  t.equal(
+    result.destination.destinationAddress,
+    VALID_SOLANA_ADDRESS,
+    "Destination address should match Solana address"
+  );
+
+  t.equal(
+    result.isIntentPayment,
+    true,
+    "Should be an intent payment (Base to Solana)"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Error: Unsupported token", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: "0x0000000000000000000000000000000000000000", // Invalid token
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  t.throws(
+    () => createPaymentBridgeConfig(config),
+    /(Unsupported token|or token)/,
+    "Should throw error for unsupported token"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Error: Invalid address for chain", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: "invalid-address",
+    toUnits: "1",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  t.throws(
+    () => createPaymentBridgeConfig(config),
+    (err: any) => {
+      // viem's getAddress throws InvalidAddressError when address is invalid
+      // The error will be thrown from validateAddressForChain before the bridge function can catch it
+      return (
+        err.name === "InvalidAddressError" ||
+        err.message?.includes("Address") ||
+        err.message?.includes("invalid")
+      );
+    },
+    "Should throw error for invalid address"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Error: Unsupported preferred token", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: polygon.chainId,
+    preferredTokenAddress: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", // Truly invalid token address
+  };
+
+  t.throws(
+    () => createPaymentBridgeConfig(config),
+    /Unknown token/,
+    "Should throw error for unsupported preferred token"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Error: Unsupported chain or token", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: 99999, // Unsupported chain
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  t.throws(
+    () => createPaymentBridgeConfig(config),
+    /Unknown chainId/,
+    "Should throw error for unsupported chain"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Intent payment detection: different chain, same token", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: polygon.chainId,
+    preferredTokenAddress: polygonUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.isIntentPayment,
+    true,
+    "Should be intent payment when chains differ"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Intent payment detection: same chain, different token", (t) => {
+  // This test assumes there are different tokens on the same chain
+  // For Base, we'll use the same token but the logic should still work
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  // When same chain and token, preferredTokenAddress will be set but
+  // the comparison checks preferredToken (symbol) vs toToken (address)
+  // So this might still be false if symbols match
+  t.equal(
+    result.isIntentPayment,
+    false,
+    "Should not be intent payment when same chain and token"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Large amount units", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "1000000", // 1 million USDC
+    preferredChain: polygon.chainId,
+    preferredTokenAddress: polygonUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.destination.amountUnits,
+    "1000000",
+    "Should handle large amount units correctly"
+  );
+
+  t.end();
+});
+
+test("createPaymentBridgeConfig - Zero amount units", (t) => {
+  const config: PaymentBridgeConfig = {
+    toChain: base.chainId,
+    toToken: baseUSDC.token,
+    toAddress: VALID_EVM_ADDRESS,
+    toUnits: "0",
+    preferredChain: base.chainId,
+    preferredTokenAddress: baseUSDC.token,
+  };
+
+  const result = createPaymentBridgeConfig(config);
+
+  t.equal(
+    result.destination.amountUnits,
+    "0",
+    "Should handle zero amount units correctly"
+  );
+
+  t.end();
+});

package/dist/chainAddress.d.ts

@@ -1,27 +0,0 @@
-import { Address } from "viem";
-export declare const EVM_CHAIN_IDS: {
-    readonly BASE: 8453;
-    readonly ETHEREUM: 1;
-    readonly POLYGON: 137;
-};
-export declare const NON_EVM_CHAIN_IDS: {
-    readonly SOLANA: 900;
-    readonly STELLAR: 1500;
-};
-export type EvmChainId = (typeof EVM_CHAIN_IDS)[keyof typeof EVM_CHAIN_IDS];
-export type NonEvmChainId = (typeof NON_EVM_CHAIN_IDS)[keyof typeof NON_EVM_CHAIN_IDS];
-export type SupportedChainId = EvmChainId | NonEvmChainId;
-export declare function isEvmChain(chainId: number): chainId is EvmChainId;
-export declare function isSolanaChain(chainId: number): boolean;
-export declare function isStellarChain(chainId: number): boolean;
-export declare function isValidEvmAddress(address: string): address is Address;
-export declare function isValidSolanaAddress(address: string): boolean;
-export declare function isValidStellarAddress(address: string): boolean;
-/**
- * Validates that an address matches the expected format for a given chain
- */
-export declare function validateAddressForChain(chainId: number, address: string): boolean;
-/**
- * Returns a human-readable chain type name
- */
-export declare function getChainTypeName(chainId: number): string;