feat/starknet-utils

Author: ljankovic-txfusion

.changeset/metal-coats-remain.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/utils': minor
+---
+
+Add Starknet address and tx utils

typescript/utils/package.json

@@ -9,6 +9,7 @@
     "ethers": "^5.7.2",
     "lodash-es": "^4.17.21",
     "pino": "^8.19.0",
+    "starknet": "^6.24.1",
     "yaml": "2.4.5"
   },
   "devDependencies": {

typescript/utils/src/addresses.test.ts

@@ -15,6 +15,10 @@ const COS_NON_ZERO_ADDR =
   'neutron1jyyjd3x0jhgswgm6nnctxvzla8ypx50tew3ayxxwkrjfxhvje6kqzvzudq';
 const SOL_ZERO_ADDR = '111111';
 const SOL_NON_ZERO_ADDR = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+const STARKNET_ZERO_ADDR =
+  '0x0000000000000000000000000000000000000000000000000000000000000000';
+const STARKNET_NON_ZERO_ADDR =
+  '0x0000000000000000000000000000000000000000000000000000000000000001';
 
 // TODO increase address utility test coverage
 describe('Address utilities', () => {
@@ -24,22 +28,26 @@ describe('Address utilities', () => {
       expect(isZeroishAddress(ETH_ZERO_ADDR)).to.be.true;
       expect(isZeroishAddress(COS_ZERO_ADDR)).to.be.true;
       expect(isZeroishAddress(SOL_ZERO_ADDR)).to.be.true;
+      expect(isZeroishAddress(STARKNET_ZERO_ADDR)).to.be.true;
     });
     it('Identifies non-0-ish addresses', () => {
       expect(isZeroishAddress(ETH_NON_ZERO_ADDR)).to.be.false;
       expect(isZeroishAddress(COS_NON_ZERO_ADDR)).to.be.false;
       expect(isZeroishAddress(SOL_NON_ZERO_ADDR)).to.be.false;
+      expect(isZeroishAddress(STARKNET_NON_ZERO_ADDR)).to.be.false;
     });
   });
 
   describe('addressToBytes', () => {
     it('Converts addresses to bytes', () => {
       expect(addressToBytes(ETH_NON_ZERO_ADDR).length).to.equal(32);
+      expect(addressToBytes(STARKNET_NON_ZERO_ADDR).length).to.equal(32);
     });
     it('Rejects zeroish addresses', () => {
       expect(() => addressToBytes(ETH_ZERO_ADDR)).to.throw(Error);
       expect(() => addressToBytes(COS_ZERO_ADDR)).to.throw(Error);
       expect(() => addressToBytes(SOL_ZERO_ADDR)).to.throw(Error);
+      expect(() => addressToBytes(STARKNET_ZERO_ADDR)).to.throw(Error);
     });
   });
 
@@ -62,6 +70,12 @@ describe('Address utilities', () => {
           ProtocolType.Ethereum,
         ),
       ).to.equal(ETH_NON_ZERO_ADDR);
+      expect(
+        bytesToProtocolAddress(
+          addressToBytes(STARKNET_NON_ZERO_ADDR),
+          ProtocolType.Starknet,
+        ),
+      ).to.equal(STARKNET_NON_ZERO_ADDR);
     });
     it('Rejects zeroish addresses', () => {
       expect(() =>

typescript/utils/src/addresses.ts

@@ -1,13 +1,20 @@
 import { fromBech32, normalizeBech32, toBech32 } from '@cosmjs/encoding';
 import { PublicKey } from '@solana/web3.js';
 import { Wallet, utils as ethersUtils } from 'ethers';
+import {
+  addAddressPadding,
+  encode,
+  num,
+  validateAndParseAddress,
+} from 'starknet';
 
 import { isNullish } from './typeof.js';
 import { Address, HexString, ProtocolType } from './types.js';
 import { assert } from './validation.js';
 
 const EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
 const SEALEVEL_ADDRESS_REGEX = /^[a-zA-Z0-9]{36,44}$/;
+const STARKNET_ADDRESS_REGEX = /^(0x)?[0-9a-fA-F]{64}$/;
 
 const HEX_BYTES32_REGEX = /^0x[a-fA-F0-9]{64}$/;
 
@@ -24,10 +31,12 @@ const COSMOS_FACTORY_TOKEN_REGEX = new RegExp(
 const EVM_TX_HASH_REGEX = /^0x([A-Fa-f0-9]{64})$/;
 const SEALEVEL_TX_HASH_REGEX = /^[a-zA-Z1-9]{88}$/;
 const COSMOS_TX_HASH_REGEX = /^(0x)?[A-Fa-f0-9]{64}$/;
+const STARKNET_TX_HASH_REGEX = /^(0x)?[0-9a-fA-F]{64}$/;
 
 const EVM_ZEROISH_ADDRESS_REGEX = /^(0x)?0*$/;
 const SEALEVEL_ZEROISH_ADDRESS_REGEX = /^1+$/;
 const COSMOS_ZEROISH_ADDRESS_REGEX = /^[a-z]{1,10}?1[0]+$/;
+const STARKNET_ZEROISH_ADDRESS_REGEX = /^(0x)?0*$/;
 
 export const ZERO_ADDRESS_HEX_32 =
   '0x0000000000000000000000000000000000000000000000000000000000000000';
@@ -48,6 +57,10 @@ export function isAddressCosmos(address: Address) {
   );
 }
 
+export function isAddressStarknet(address: Address) {
+  return STARKNET_ADDRESS_REGEX.test(address);
+}
+
 export function getAddressProtocolType(address: Address) {
   if (!address) return undefined;
   if (isAddressEvm(address)) {
@@ -56,6 +69,8 @@ export function getAddressProtocolType(address: Address) {
     return ProtocolType.Cosmos;
   } else if (isAddressSealevel(address)) {
     return ProtocolType.Sealevel;
+  } else if (isAddressStarknet(address)) {
+    return ProtocolType.Starknet;
   } else {
     return undefined;
   }
@@ -112,13 +127,23 @@ export function isValidAddressCosmos(address: Address) {
   }
 }
 
+export function isValidAddressStarknet(address: Address) {
+  try {
+    const isValid = address && validateAndParseAddress(address);
+    return !!isValid;
+  } catch {
+    return false;
+  }
+}
+
 export function isValidAddress(address: Address, protocol?: ProtocolType) {
   return routeAddressUtil(
     {
       [ProtocolType.Ethereum]: isValidAddressEvm,
       [ProtocolType.Sealevel]: isValidAddressSealevel,
       [ProtocolType.Cosmos]: isValidAddressCosmos,
       [ProtocolType.CosmosNative]: isValidAddressCosmos,
+      [ProtocolType.Starknet]: isValidAddressStarknet,
     },
     address,
     false,
@@ -153,6 +178,14 @@ export function normalizeAddressCosmos(address: Address) {
   }
 }
 
+export function normalizeAddressStarknet(address: Address) {
+  if (isZeroishAddress(address)) return address;
+  try {
+    return validateAndParseAddress(address);
+  } catch {
+    return address;
+  }
+}
 export function normalizeAddress(address: Address, protocol?: ProtocolType) {
   return routeAddressUtil(
     {
@@ -179,6 +212,10 @@ export function eqAddressCosmos(a1: Address, a2: Address) {
   return normalizeAddressCosmos(a1) === normalizeAddressCosmos(a2);
 }
 
+export function eqAddressStarknet(a1: Address, a2: Address) {
+  return normalizeAddressStarknet(a1) === normalizeAddressStarknet(a2);
+}
+
 export function eqAddress(a1: Address, a2: Address) {
   const p1 = getAddressProtocolType(a1);
   const p2 = getAddressProtocolType(a2);
@@ -189,6 +226,7 @@ export function eqAddress(a1: Address, a2: Address) {
       [ProtocolType.Sealevel]: (_a1) => eqAddressSol(_a1, a2),
       [ProtocolType.Cosmos]: (_a1) => eqAddressCosmos(_a1, a2),
       [ProtocolType.CosmosNative]: (_a1) => eqAddressCosmos(_a1, a2),
+      [ProtocolType.Starknet]: (_a1) => eqAddressStarknet(_a1, a2),
     },
     a1,
     false,
@@ -208,6 +246,10 @@ export function isValidTransactionHashCosmos(input: string) {
   return COSMOS_TX_HASH_REGEX.test(input);
 }
 
+export function isValidTransactionHashStarknet(input: string) {
+  return STARKNET_TX_HASH_REGEX.test(input);
+}
+
 export function isValidTransactionHash(input: string, protocol: ProtocolType) {
   if (protocol === ProtocolType.Ethereum) {
     return isValidTransactionHashEvm(input);
@@ -217,6 +259,8 @@ export function isValidTransactionHash(input: string, protocol: ProtocolType) {
     return isValidTransactionHashCosmos(input);
   } else if (protocol === ProtocolType.CosmosNative) {
     return isValidTransactionHashCosmos(input);
+  } else if (protocol === ProtocolType.Starknet) {
+    return isValidTransactionHashStarknet(input);
   } else {
     return false;
   }
@@ -226,7 +270,8 @@ export function isZeroishAddress(address: Address) {
   return (
     EVM_ZEROISH_ADDRESS_REGEX.test(address) ||
     SEALEVEL_ZEROISH_ADDRESS_REGEX.test(address) ||
-    COSMOS_ZEROISH_ADDRESS_REGEX.test(address)
+    COSMOS_ZEROISH_ADDRESS_REGEX.test(address) ||
+    STARKNET_ZEROISH_ADDRESS_REGEX.test(address)
   );
 }
 
@@ -271,6 +316,11 @@ export function addressToBytesCosmos(address: Address): Uint8Array {
   return fromBech32(address).data;
 }
 
+export function addressToBytesStarknet(address: Address): Uint8Array {
+  const normalizedAddress = validateAndParseAddress(address);
+  return num.hexToBytes(normalizedAddress);
+}
+
 export function addressToBytes(
   address: Address,
   protocol?: ProtocolType,
@@ -281,6 +331,7 @@ export function addressToBytes(
       [ProtocolType.Sealevel]: addressToBytesSol,
       [ProtocolType.Cosmos]: addressToBytesCosmos,
       [ProtocolType.CosmosNative]: addressToBytesCosmos,
+      [ProtocolType.Starknet]: addressToBytesStarknet,
     },
     address,
     new Uint8Array(),
@@ -349,6 +400,11 @@ export function bytesToAddressCosmos(
   return toBech32(prefix, bytes);
 }
 
+export function bytesToAddressStarknet(bytes: Uint8Array): Address {
+  const hexString = encode.buf2hex(bytes);
+  return addAddressPadding(hexString);
+}
+
 export function bytesToProtocolAddress(
   bytes: Uint8Array,
   toProtocol: ProtocolType,
@@ -366,6 +422,8 @@ export function bytesToProtocolAddress(
     return bytesToAddressCosmos(bytes, prefix!);
   } else if (toProtocol === ProtocolType.CosmosNative) {
     return bytesToAddressCosmos(bytes, prefix!);
+  } else if (toProtocol === ProtocolType.Starknet) {
+    return bytesToAddressStarknet(bytes);
   } else {
     throw new Error(`Unsupported protocol for address ${toProtocol}`);
   }

typescript/utils/src/index.ts

@@ -5,10 +5,12 @@ export {
   addressToBytesCosmos,
   addressToBytesEvm,
   addressToBytesSol,
+  addressToBytesStarknet,
   bytes32ToAddress,
   bytesToAddressCosmos,
   bytesToAddressEvm,
   bytesToAddressSol,
+  bytesToAddressStarknet,
   bytesToProtocolAddress,
   capitalizeAddress,
   convertToProtocolAddress,
@@ -17,25 +19,30 @@ export {
   eqAddressCosmos,
   eqAddressEvm,
   eqAddressSol,
+  eqAddressStarknet,
   getAddressProtocolType,
   isAddress,
   isAddressCosmos,
   isAddressEvm,
   isAddressSealevel,
+  isAddressStarknet,
   isValidAddress,
   isValidAddressCosmos,
   isValidAddressEvm,
   isValidAddressSealevel,
+  isValidAddressStarknet,
   isPrivateKeyEvm,
   isValidTransactionHash,
   isValidTransactionHashCosmos,
   isValidTransactionHashEvm,
   isValidTransactionHashSealevel,
+  isValidTransactionHashStarknet,
   isZeroishAddress,
   normalizeAddress,
   normalizeAddressCosmos,
   normalizeAddressEvm,
   normalizeAddressSealevel,
+  normalizeAddressStarknet,
   padBytesToLength,
   shortenAddress,
   strip0x,

yarn.lock

@@ -8021,6 +8021,7 @@ __metadata:
     pino: "npm:^8.19.0"
     prettier: "npm:^3.5.3"
     sinon: "npm:^13.0.2"
+    starknet: "npm:^6.24.1"
     typescript: "npm:5.3.3"
     yaml: "npm:2.4.5"
   languageName: unknown