@snowbridge/base-types 1.0.5 → 1.0.6

package/src/index.ts

@@ -1,8 +1,19 @@
+export type BridgeInfo = {
+  environment: Environment;
+  routes: readonly TransferRoute[];
+  registry: AssetRegistry;
+  chains: ChainMap;
+};
+
 export type AccountType = "AccountId20" | "AccountId32";
 
-export interface XC20TokenMap {
-  [xc20: string]: string;
-}
+export type XcmVersion = "v4" | "v5";
+
+export type EthereumKind = "ethereum" | "ethereum_l2";
+export type ParachainKind = "polkadot" | "kusama";
+export type ChainKind = EthereumKind | ParachainKind;
+
+export type XC20TokenMap = Record<string, string>;
 
 export type ERC20Metadata = {
   token: string;
@@ -12,15 +23,18 @@ export type ERC20Metadata = {
   foreignId?: string;
   // The gas cost of a local transfer, which involves unlocking for ENA and minting for PNA.
   deliveryGas?: bigint;
+  // For ERC-20 tokens on L2 chains that have a corresponding mapped L1 token address.
+  swapTokenAddress?: string;
+  // fee tier for uniswap call in basis points (e.g., 500 = 0.05%)
+  swapFee?: number;
 };
 
-export interface ERC20MetadataMap {
-  [token: string]: ERC20Metadata;
-}
+export type ERC20MetadataMap = Record<string, ERC20Metadata>;
 
-export type EthereumChain = {
-  chainId: number;
-  id: string;
+export type EthereumChain = ChainId & {
+  kind: EthereumKind;
+  key: `${EthereumKind}_${number}`;
+  name?: string;
   evmParachainId?: number;
   assets: ERC20MetadataMap;
   precompile?: `0x${string}`;
@@ -64,12 +78,11 @@ export type Asset = {
   foreignId?: string;
 };
 
-export interface AssetMap {
-  [token: string]: Asset;
-}
+export type AssetMap = Record<string, Asset>;
 
-export type Parachain = {
-  parachainId: number;
+export type Parachain = ChainId & {
+  kind: ParachainKind;
+  key: `${ParachainKind}_${number}`;
   info: ChainProperties;
   features: {
     hasPalletXcm: boolean;
@@ -77,6 +90,12 @@ export type Parachain = {
     hasTxPaymentApi: boolean;
     hasDryRunRpc: boolean;
     hasDotBalance: boolean;
+    hasEthBalance: boolean;
+    hasXcmPaymentApi: boolean;
+    supportsAliasOrigin: boolean;
+    xcmVersion: XcmVersion;
+    /** @deprecated Remove once V2 is fully rolled out to all parachains */
+    supportsV2: boolean;
   };
   assets: AssetMap;
   estimatedExecutionFeeDOT: bigint;
@@ -84,9 +103,12 @@ export type Parachain = {
   xcDOT?: string;
 };
 
-export interface ParachainMap {
-  [paraId: string]: Parachain;
-}
+export type EthereumChainMap = Record<ChainKey<EthereumKind>, EthereumChain>;
+export type ParachainMap = Record<ChainKey<ParachainKind>, Parachain>;
+export type ChainRef = ChainId & {
+  key: ChainKey<ChainKind>;
+};
+export type ChainMap = Record<string, ChainRef>;
 
 export type KusamaConfig = {
   assetHubParaId: number;
@@ -94,6 +116,110 @@ export type KusamaConfig = {
   parachains: ParachainMap;
 };
 
+export type Environment = {
+  name: string;
+  // Ethereum
+  ethChainId: number;
+  gatewayContract: string;
+  beefyContract: string;
+  beaconApiUrl: string;
+  ethereumChains: Record<string, string>;
+  // Substrate
+  assetHubParaId: number;
+  bridgeHubParaId: number;
+  /** @deprecated Remove once V2 is fully rolled out to all parachains */
+  v2_parachains?: readonly number[];
+  relaychainUrl: string;
+  parachains: {
+    [paraId: string]: string;
+  };
+  // Indexer
+  indexerGraphQlUrl: string;
+  kusama?: {
+    assetHubParaId: number;
+    bridgeHubParaId: number;
+    parachains: Record<string, string>;
+  };
+  // Assets
+  assetOverrides?: AssetOverrideMap;
+  precompiles?: PrecompileMap;
+  metadataOverrides?: ERC20MetadataOverrideMap;
+  // L2 Forwarding
+  l2Bridge?: {
+    acrossAPIUrl: string;
+    l1AdapterAddress: string;
+    l1HandlerAddress: string;
+    l1FeeTokenAddress: string;
+    l1SwapRouterAddress: string;
+    l1SwapQuoterAddress: string;
+    l2Chains: Record<number, L2ForwardMetadata>;
+  };
+};
+
+export type ChainId = {
+  kind: ChainKind;
+  /** Ethereum chain id or polkadot parachain id.
+   */
+  id: number;
+};
+
+export type TransferRoute = {
+  from: ChainId;
+  to: ChainId;
+  assets: readonly string[];
+};
+
+export type TransferKind =
+  | "polkadot->polkadot"
+  | "kusama->polkadot"
+  | "polkadot->kusama"
+  | "polkadot->ethereum"
+  | "ethereum->polkadot"
+  | "ethereum->ethereum"
+  | "polkadot->ethereum_l2"
+  | "ethereum_l2->polkadot";
+
+export type ChainKey<T extends string> = `${T}_${number}`;
+
+export type Source = ChainId & {
+  key: ChainKey<ChainKind>;
+  destinations: Record<
+    ChainKey<ChainKind>,
+    ChainId & {
+      key: ChainKey<ChainKind>;
+      assets: string[];
+    }
+  >;
+};
+
+export type TransferLocation = ParachainLocation | EthereumLocation;
+
+export type ParachainLocation = ChainId & {
+  kind: ParachainKind;
+  key: ChainKey<ParachainKind>;
+  parachain: Parachain;
+};
+
+export type EthereumLocation = ChainId & {
+  kind: EthereumKind;
+  key: ChainKey<EthereumKind>;
+  ethChain: EthereumChain;
+  parachain?: Parachain;
+};
+
+export type AssetOverrideMap = Record<string, Asset[]>;
+
+export type ERC20MetadataOverrideMap = Record<
+  string,
+  {
+    name?: string;
+    symbol?: string;
+    decimals?: number;
+  }
+>;
+
+export type PrecompileMap = Record<string, `0x${string}`>;
+
 export type AssetRegistry = {
   timestamp: string;
   environment: string;
@@ -103,9 +229,78 @@ export type AssetRegistry = {
   bridgeHubParaId: number;
   relaychain: ChainProperties;
   bridgeHub: ChainProperties;
-  ethereumChains: {
-    [chainId: string]: EthereumChain;
-  };
+  ethereumChains: EthereumChainMap;
   parachains: ParachainMap;
-  kusama: KusamaConfig | undefined;
+  kusama?: KusamaConfig;
+};
+
+export type {
+  EthereumProvider,
+  EthereumProviderTypes,
+  FeeData,
+  GatewayV1OutboundMessageAccepted,
+  GatewayV2OutboundMessageAccepted,
+  L1AdapterDepositParams,
+  L1LegacySwapRouterExactOutputSingleParams,
+  L1SwapRouterExactOutputSingleParams,
+  MultiAddressStruct,
+} from "./provider";
+
+export type ContractCall = {
+  target: string;
+  calldata: string;
+  value: bigint;
+  gas: bigint;
 };
+
+export type SubstrateAccount = {
+  nonce: bigint;
+  consumers: bigint;
+  providers: bigint;
+  sufficients: bigint;
+  data: {
+    free: bigint;
+    reserved: bigint;
+    frozen: bigint;
+    transferable: bigint;
+    total: bigint;
+  };
+};
+
+export type PNAMap = Record<
+  string,
+  {
+    token: string;
+    foreignId: string;
+    ethereumlocation: any;
+  }
+>;
+
+export type AssetSwapRoute = {
+  inputToken: string;
+  outputToken: string;
+  swapFee: number; // fee tier for uniswap call in basis points (e.g., 500 = 0.05%)
+};
+
+export type L2ForwardMetadata = {
+  adapterAddress: string;
+  feeTokenAddress: string;
+  swapRoutes: readonly AssetSwapRoute[];
+};
+
+export type FeeEstimateErrorDetails = {
+  type: string;
+  code: string;
+  status: number;
+  message: string;
+  id: string;
+};
+export class FeeEstimateError extends Error {
+  readonly details: FeeEstimateErrorDetails;
+  constructor(details: FeeEstimateErrorDetails) {
+    super(details.message);
+    this.details = details;
+  }
+}
+
+export * from "./contracts";

package/src/provider.ts

@@ -0,0 +1,228 @@
+import type {
+  DepositParamsStruct,
+  IGatewayV1,
+  IGatewayV2,
+  SendParamsStruct,
+  SwapParamsStruct,
+} from "./contracts";
+
+export type MultiAddressStruct = {
+  kind: number;
+  data: string;
+};
+
+export type GatewayV1OutboundMessageAccepted = {
+  channelId: string;
+  nonce: bigint;
+  messageId: string;
+  blockNumber: number;
+  blockHash: string;
+  txHash: string;
+  txIndex: number;
+};
+
+export type GatewayV2OutboundMessageAccepted = {
+  nonce: bigint;
+  payload: {
+    origin: string;
+    assets: [number, string][];
+    xcm: [number, string];
+    claimer: string;
+    value: bigint;
+    executionFee: bigint;
+    relayerFee: bigint;
+  };
+  blockNumber: number;
+  blockHash: string;
+  txHash: string;
+  txIndex: number;
+};
+
+export type FeeData = {
+  gasPrice: bigint | null;
+  maxFeePerGas: bigint | null;
+  maxPriorityFeePerGas: bigint | null;
+};
+
+export type EncodedMultiAddress = MultiAddressStruct;
+
+export type L1AdapterDepositParams = {
+  inputToken: string;
+  outputToken: string;
+  inputAmount: bigint;
+  outputAmount: bigint;
+  destinationChainId: number;
+  fillDeadlineBuffer: bigint;
+};
+
+export type L1SwapRouterExactOutputSingleParams = {
+  tokenIn: string;
+  tokenOut: string;
+  fee: bigint;
+  recipient: string;
+  deadline: bigint;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  sqrtPriceLimitX96: bigint;
+};
+
+export type L1LegacySwapRouterExactOutputSingleParams = {
+  tokenIn: string;
+  tokenOut: string;
+  fee: bigint;
+  recipient: string;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  sqrtPriceLimitX96: bigint;
+};
+
+export interface EthereumProviderTypes {
+  Connection: unknown;
+  Contract: unknown;
+  Abi: unknown;
+  TransactionReceipt: unknown;
+  ContractTransaction: unknown;
+}
+
+export interface EthereumProvider<T extends EthereumProviderTypes> {
+  readonly providerTypes: T;
+  createProvider(url: string): T["Connection"];
+  destroyProvider(provider: T["Connection"]): void;
+  destroyContract(contract: T["Contract"]): Promise<void>;
+  connectContract(
+    address: string,
+    abi: T["Abi"],
+    provider: T["Connection"],
+  ): T["Contract"];
+  erc20Balance(
+    provider: T["Connection"],
+    tokenAddress: string,
+    owner: string,
+    spender: string,
+  ): Promise<{ balance: bigint; gatewayAllowance: bigint }>;
+  encodeFunctionData(
+    abi: T["Abi"],
+    method: string,
+    args: readonly unknown[],
+  ): string;
+  decodeFunctionResult<U = unknown>(
+    abi: T["Abi"],
+    method: string,
+    data: string,
+  ): U;
+  encodeNativeAsset(tokenAddress: string, amount: bigint): string;
+  l1AdapterDepositNativeEther(
+    params: L1AdapterDepositParams,
+    recipient: string,
+    topic: string,
+  ): string;
+  l1AdapterDepositToken(
+    params: L1AdapterDepositParams,
+    recipient: string,
+    topic: string,
+  ): string;
+  l1SwapRouterExactOutputSingle(
+    params: L1SwapRouterExactOutputSingleParams,
+  ): string;
+  l1LegacySwapRouterExactOutputSingle(
+    params: L1LegacySwapRouterExactOutputSingleParams,
+  ): string;
+  beneficiaryMultiAddress(beneficiary: string): MultiAddressStruct;
+  estimateGas(
+    provider: T["Connection"],
+    tx: T["ContractTransaction"],
+  ): Promise<bigint>;
+  getTransactionCount(
+    provider: T["Connection"],
+    address: string,
+    blockTag?: "latest" | "pending",
+  ): Promise<number>;
+  gatewayV1SendToken(
+    provider: T["Connection"],
+    gatewayAddress: string,
+    sender: string,
+    token: string,
+    destinationChain: number,
+    destinationAddress: MultiAddressStruct,
+    destinationFee: bigint,
+    amount: bigint,
+    value: bigint,
+  ): Promise<T["ContractTransaction"]>;
+  gatewayV2RegisterToken(
+    provider: T["Connection"],
+    gatewayAddress: string,
+    sender: string,
+    token: string,
+    network: number,
+    executionFee: bigint,
+    relayerFee: bigint,
+    value: bigint,
+  ): Promise<T["ContractTransaction"]>;
+  gatewayV2CreateAgent(
+    provider: T["Connection"],
+    gatewayAddress: string,
+    id: string,
+  ): Promise<T["ContractTransaction"]>;
+  gatewayV2SendMessage(
+    provider: T["Connection"],
+    gatewayAddress: string,
+    sender: string,
+    xcm: Uint8Array,
+    assets: string[],
+    claimer: Uint8Array,
+    executionFee: bigint,
+    relayerFee: bigint,
+    value: bigint,
+  ): Promise<T["ContractTransaction"]>;
+  l2AdapterSendEtherAndCall(
+    provider: T["Connection"],
+    adapterAddress: string,
+    sender: string,
+    params: DepositParamsStruct,
+    sendParams: SendParamsStruct,
+    recipient: string,
+    topic: string,
+    value?: bigint,
+  ): Promise<T["ContractTransaction"]>;
+  l2AdapterSendTokenAndCall(
+    provider: T["Connection"],
+    adapterAddress: string,
+    sender: string,
+    params: DepositParamsStruct,
+    swapParams: SwapParamsStruct,
+    sendParams: SendParamsStruct,
+    recipient: string,
+    topic: string,
+  ): Promise<T["ContractTransaction"]>;
+  evmParachainTransferAssetsUsingTypeAndThenAddress(
+    provider: T["Connection"],
+    precompileAddress: string,
+    sourceAccount: string,
+    destination: [number, string[]],
+    assets: [string, bigint][],
+    assetsTransferType: number,
+    remoteFeesIdIndex: number,
+    feesTransferType: number,
+    customXcmHex: string,
+  ): Promise<T["ContractTransaction"]>;
+  getBalance(provider: T["Connection"], address: string): Promise<bigint>;
+  getFeeData(provider: T["Connection"]): Promise<FeeData>;
+  parseUnits(value: string, decimals: number): bigint;
+  gatewayOperatingMode(
+    gateway: T["Contract"] & (IGatewayV1 | IGatewayV2),
+  ): Promise<bigint>;
+  gatewayChannelOperatingModeOf(
+    gateway: T["Contract"] & IGatewayV1,
+    channelId: string,
+  ): Promise<bigint>;
+  isContractAddress(
+    provider: T["Connection"],
+    address: string,
+  ): Promise<boolean>;
+  scanGatewayV1OutboundMessageAccepted(
+    receipt: T["TransactionReceipt"],
+  ): GatewayV1OutboundMessageAccepted | null;
+  scanGatewayV2OutboundMessageAccepted(
+    receipt: T["TransactionReceipt"],
+  ): GatewayV2OutboundMessageAccepted | null;
+}