@across-protocol/sdk 4.1.23 → 4.1.25-beta.1

package/scripts/build-bigint-buffer.js

@@ -0,0 +1,49 @@
+/**
+ * Build Script for bigint-buffer Native Module
+ * 
+ * Purpose:
+ * This script handles the native compilation of the bigint-buffer module, which provides
+ * high-performance BigInt <-> Buffer conversions using native C++ code.
+ * 
+ * Why JavaScript and not TypeScript or an embedded shell script:
+ * 1. This is a build script that runs during package installation (postinstall)
+ * 2. Using TypeScript would require the TypeScript compiler or ts-node to be available during installation
+ * 3. Plain JavaScript ensures this script can run immediately without compilation
+ * 4. This script is operating system agnostic, so it can be run on any platform that supports Node.js
+ */
+
+const { execSync } = require('child_process');
+const { existsSync } = require('fs');
+const path = require('path');
+
+try {
+  // Check if the bigint-buffer module exists in node_modules
+  // Using path.join for cross-platform compatibility (Windows/Unix)
+  const bigintBufferPath = path.join(process.cwd(), 'node_modules/bigint-buffer');
+  
+  // Skip if module isn't installed
+  if (!existsSync(bigintBufferPath)) {
+    console.log('Skipping bigint-buffer build: folder not found');
+    process.exit(0);
+  }
+
+  // Verify node-gyp (native module build tool) is available
+  // node-gyp is required to compile the C++ code in bigint-buffer
+  try {
+    execSync('command -v node-gyp', { stdio: 'ignore' });
+  } catch {
+    console.log('Skipping bigint-buffer build: node-gyp not found');
+    process.exit(0);
+  }
+
+  // Change to the module directory and run the native build
+  // node-gyp configure: Creates platform-specific build files
+  // node-gyp build: Compiles the native code
+  process.chdir(bigintBufferPath);
+  execSync('node-gyp configure', { stdio: 'inherit' });
+  execSync('node-gyp build', { stdio: 'inherit' });
+} catch (error) {
+  // Proper error handling for build failures
+  console.error('Error building bigint-buffer:', error);
+  process.exit(1);
+} 

package/src/utils/AddressUtils.ts

@@ -1,5 +1,6 @@
 import { providers, utils } from "ethers";
-import { BigNumber } from "./BigNumberUtils";
+import bs58 from "bs58";
+import { BigNumber, chainIsEvm } from "./";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -68,3 +69,180 @@ export function isValidEvmAddress(address: string): boolean {
     return false;
   }
 }
+
+/**
+ * Creates the proper address type given the input chain ID corresponding to the address's origin network.
+ * @param address Stringified address type to convert. Can be either hex encoded or base58 encoded.
+ * @param chainId Network ID corresponding to the input address, used to determine which address type to output.
+ * @returns a child `Address` type most fitting for the chain ID.
+ * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
+ */
+export function toAddressType(address: string, chainId: number): Address | EvmAddress | SvmAddress {
+  try {
+    if (chainIsEvm(chainId)) {
+      return EvmAddress.from(address);
+    }
+    return SvmAddress.from(address);
+  } catch (e) {
+    // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
+    // return an unchecked address type.
+    return new Address(utils.arrayify(address));
+  }
+}
+
+// The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
+// which for this class, is a bytes32 hex string.
+export class Address {
+  readonly rawAddress: Uint8Array;
+
+  // Keep all address types in cache so that we may lazily evaluate them when necessary.
+  evmAddress: string | undefined = undefined;
+  bytes32Address: string | undefined = undefined;
+  svmAddress: string | undefined = undefined;
+  bnAddress: BigNumber | undefined = undefined;
+
+  constructor(_rawAddress: Uint8Array) {
+    // The only validation done here is checking that the address is at most a 32-byte address, which  will be well-defined on any supported network.
+    // Further validation is done on the subclasses so that we can guarantee that, for example, an EvmAddress type will always contain a valid, 20-byte
+    // EVM address.
+    if (_rawAddress.length > 32) {
+      throw new Error(`Address ${utils.hexlify(_rawAddress)} cannot be longer than 32 bytes.`);
+    }
+    // Ensure all addresses in this class are internally stored as 32 bytes.
+    this.rawAddress = utils.zeroPad(_rawAddress, 32);
+  }
+
+  // Converts the address into a bytes32 string. Note that the output bytes will be lowercase so that it matches ethers event data. This function will never
+  // throw since address length validation was done at construction time.
+  toBytes32(): string {
+    return (this.bytes32Address ??= utils.hexZeroPad(utils.hexlify(this.rawAddress), 32).toLowerCase());
+  }
+
+  // Converts the address (can be bytes32 or bytes20) to its base58 counterpart. This conversion will always succeed, even if the input address is not valid on Solana,
+  // as this address may be needed to represent an EVM address on Solana.
+  toBase58(): string {
+    return (this.svmAddress ??= bs58.encode(this.rawAddress));
+  }
+
+  // Converts the address to a BigNumber type.
+  toBigNumber(): BigNumber {
+    return (this.bnAddress ??= BigNumber.from(this.toBytes32()));
+  }
+
+  // Converts the address to a valid EVM address. If it is unable to convert the address to a valid EVM address for some reason, such as if this address
+  // is longer than 20 bytes, then this function will throw an error.
+  toEvmAddress(): string {
+    const parseRawAddress = () => {
+      const hexString = utils.hexlify(this.rawAddress);
+      const rawAddress = utils.hexZeroPad(utils.hexStripZeros(hexString), 20);
+      return utils.getAddress(rawAddress);
+    };
+    return (this.evmAddress ??= parseRawAddress());
+  }
+
+  // Converts the address to a hex string. This method should be overriden by subclasses to obtain more meaningful
+  // address representations for the target chain ID.
+  toAddress(): string {
+    return this.toBytes32();
+  }
+
+  // Implements `Hexable` for `Address`. Needed for encoding purposes. This class is treated by default as a bytes32 primitive type, but can change for subclasses.
+  toHexString(): string {
+    return this.toBytes32();
+  }
+
+  // Checks if this address can be coerced into a bytes20 evm address. Returns true if it is possible and false otherwise.
+  isValidEvmAddress(): boolean {
+    try {
+      this.toAddress();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Checks if the address is valid on the given chain ID.
+  isValidOn(chainId: number): boolean {
+    if (chainIsEvm(chainId)) {
+      return this.isValidEvmAddress();
+    }
+    // Assume the address is always valid on Solana.
+    return true;
+  }
+
+  // Checks if the object is an address by looking at whether it has an Address constructor.
+  static isAddress(obj: unknown): boolean {
+    return obj instanceof this;
+  }
+
+  // Converts the input address to a 32-byte hex data string.
+  toString(): string {
+    return this.toHexString();
+  }
+
+  // Checks if the address is the zero address.
+  isZeroAddress(): boolean {
+    return utils.stripZeros(this.rawAddress).length === 0;
+  }
+
+  // Checks if the other address is equivalent to this address.
+  eq(other: Address): boolean {
+    return this.toString() === other.toString();
+  }
+
+  // Compares Addresses by first converting them to BigNumbers.
+  compare(otherAddress: Address): 1 | -1 | 0 {
+    // Convert address strings to BigNumbers and then sort numerical value of the BigNumber, which sorts the addresses
+    // effectively by their hex value.
+    const bnAddressA = this.toBigNumber();
+    const bnAddressB = otherAddress.toBigNumber();
+    if (bnAddressA.gt(bnAddressB)) {
+      return 1;
+    } else if (bnAddressA.lt(bnAddressB)) {
+      return -1;
+    } else {
+      return 0;
+    }
+  }
+}
+
+// Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
+export class EvmAddress extends Address {
+  // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
+  constructor(rawAddress: Uint8Array) {
+    super(rawAddress);
+    const hexString = utils.hexlify(rawAddress);
+    if (!this.isValidEvmAddress()) {
+      throw new Error(`${hexString} is not a valid EVM address`);
+    }
+  }
+
+  // Override `toAddress` to return the 20-byte representation address.
+  override toAddress(): string {
+    return this.toEvmAddress();
+  }
+
+  // Constructs a new EvmAddress type.
+  static from(hexString: string): EvmAddress {
+    return new this(utils.arrayify(hexString));
+  }
+}
+
+// Subclass of address which strictly deals SVM addresses. These addresses are guaranteed to be valid SVM addresses, so `toBase58` will always produce a valid Solana address.
+export class SvmAddress extends Address {
+  // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
+  constructor(rawAddress: Uint8Array) {
+    super(rawAddress);
+  }
+
+  // Override the toAddress function for SVM addresses only since while they will never have a defined 20-byte representation. The base58 encoded addresses are also the encodings
+  // used in TOKEN_SYMBOLS_MAP.
+  override toAddress(): string {
+    return this.toBase58();
+  }
+
+  // Constructs a new SvmAddress type.
+  static from(bs58Address: string): SvmAddress {
+    return new this(bs58.decode(bs58Address));
+  }
+}

package/src/utils/NetworkUtils.ts

@@ -130,9 +130,17 @@ export function chainIsL1(chainId: number): boolean {
  * @returns True if chain corresponding to chainId has an EVM-like execution layer.
  */
 export function chainIsEvm(chainId: number): boolean {
-  chainId;
-  // TODO: Fix when we support non-EVM chains.
-  return true;
+  // TODO: Update when additional execution layers beyond EVM and SVM are supported.
+  return PUBLIC_NETWORKS[chainId]?.family !== ChainFamily.SVM;
+}
+
+/**
+ * Determines whether a chain ID runs on an SVM-like execution layer.
+ * @param chainId Chain ID to evaluate.
+ * @returns True if chain corresponding to chainId has an SVM-like execution layer.
+ */
+export function chainIsSvm(chainId: number): boolean {
+  return PUBLIC_NETWORKS[chainId]?.family === ChainFamily.SVM;
 }
 
 /**