feat: move starkname to provider

__tests__/account.test.ts

@@ -293,7 +293,7 @@ describe('deploy and test Wallet', () => {
       const address = await account.getAddressFromStarkName('ben.stark', namingAddress);
       expect(hexToDecimalString(address as string)).toEqual(hexToDecimalString(account.address));
 
-      const name = await account.getStarkName(namingAddress);
+      const name = await account.getStarkName(undefined, namingAddress);
       expect(name).toEqual('ben.stark');
     });
   });

__tests__/utils/starknetId.test.ts

@@ -28,6 +28,10 @@ describe('Should tets StarknetId utils', () => {
     }
   });
 
+  test('Should test useEncoded and useDecoded hook with an empty string', () => {
+    expect(useDecoded([])).toBe('');
+  });
+
   test('Should test useDecoded and useEncoded hook with an encoded number', () => {
     for (let index = 0; index < 2500; index += 1) {
       const decoded = useDecoded([new BN(index)]);

src/account/default.ts

@@ -1,5 +1,3 @@
-import { BN } from 'bn.js';
-
 import { UDC, ZERO } from '../constants';
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
@@ -39,10 +37,9 @@ import {
   pedersen,
   transactionVersion,
 } from '../utils/hash';
-import { BigNumberish, hexToDecimalString, toBN, toCairoBool } from '../utils/number';
+import { BigNumberish, toBN, toCairoBool } from '../utils/number';
 import { parseContract } from '../utils/provider';
 import { compileCalldata, estimatedFeeToMaxFee, randomAddress } from '../utils/stark';
-import { getStarknetIdContract, useDecoded, useEncoded } from '../utils/starknetId';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -67,52 +64,6 @@ export class Account extends Provider implements AccountInterface {
     return super.getNonceForAddress(this.address, blockIdentifier);
   }
 
-  public async getStarkName(StarknetIdContract?: string): Promise<string | Error> {
-    const chainId = await this.getChainId();
-    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
-
-    try {
-      const hexDomain = await this.callContract({
-        contractAddress: contract,
-        entrypoint: 'address_to_domain',
-        calldata: compileCalldata({
-          address: this.address,
-        }),
-      });
-      const decimalDomain = hexDomain.result
-        .map((element) => new BN(hexToDecimalString(element)))
-        .slice(1);
-
-      const stringDomain = useDecoded(decimalDomain);
-
-      return stringDomain;
-    } catch {
-      return Error('Could not get stark name');
-    }
-  }
-
-  public async getAddressFromStarkName(
-    name: string,
-    StarknetIdContract?: string
-  ): Promise<string | Error> {
-    const chainId = await this.getChainId();
-    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
-
-    try {
-      const addressData = await this.callContract({
-        contractAddress: contract,
-        entrypoint: 'domain_to_address',
-        calldata: compileCalldata({
-          domain: [useEncoded(name.replace('.stark', '')).toString(10)],
-        }),
-      });
-
-      return addressData.result[0];
-    } catch {
-      return Error('Could not get address from stark name');
-    }
-  }
-
   public async estimateFee(
     calls: AllowArray<Call>,
     estimateFeeDetails?: EstimateFeeDetails | undefined
@@ -672,4 +623,11 @@ export class Account extends Provider implements AccountInterface {
       },
     };
   }
+
+  public override async getStarkName(
+    address: BigNumberish = this.address, // default to the wallet address
+    StarknetIdContract?: string
+  ): Promise<string> {
+    return super.getStarkName(address, StarknetIdContract);
+  }
 }

src/provider/default.ts

@@ -25,6 +25,7 @@ import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProvider, RpcProviderOptions } from './rpc';
 import { SequencerProvider, SequencerProviderOptions } from './sequencer';
+import { getAddressFromStarkName, getStarkName } from './starknetId';
 import { BlockIdentifier } from './utils';
 
 export interface ProviderOptions {
@@ -207,4 +208,12 @@ export class Provider implements ProviderInterface {
   public async getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse> {
     return this.provider.getStateUpdate(blockIdentifier);
   }
+
+  public async getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string> {
+    return getStarkName(this, address, StarknetIdContract);
+  }
+
+  public async getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string> {
+    return getAddressFromStarkName(this, name, StarknetIdContract);
+  }
 }

src/provider/rpc.ts

@@ -31,6 +31,7 @@ import { parseCalldata, wait } from '../utils/provider';
 import { RPCResponseParser } from '../utils/responseParser/rpc';
 import { LibraryError } from './errors';
 import { ProviderInterface } from './interface';
+import { getAddressFromStarkName, getStarkName } from './starknetId';
 import { Block, BlockIdentifier } from './utils';
 
 export type RpcProviderOptions = {
@@ -500,4 +501,12 @@ export class RpcProvider implements ProviderInterface {
   ): Promise<TransactionSimulationResponse> {
     throw new Error('RPC does not implement simulateTransaction function');
   }
+
+  public async getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string> {
+    return getStarkName(this, address, StarknetIdContract);
+  }
+
+  public async getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string> {
+    return getAddressFromStarkName(this, name, StarknetIdContract);
+  }
 }

src/provider/sequencer.ts

@@ -44,6 +44,7 @@ import { randomAddress } from '../utils/stark';
 import { buildUrl } from '../utils/url';
 import { GatewayError, HttpError, LibraryError } from './errors';
 import { ProviderInterface } from './interface';
+import { getAddressFromStarkName, getStarkName } from './starknetId';
 import { Block, BlockIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha' | 'goerli-alpha-2';
@@ -605,4 +606,12 @@ export class SequencerProvider implements ProviderInterface {
     const args = new Block(blockIdentifier).sequencerIdentifier;
     return this.fetchEndpoint('get_block_traces', { ...args });
   }
+
+  public async getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string> {
+    return getStarkName(this, address, StarknetIdContract);
+  }
+
+  public async getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string> {
+    return getAddressFromStarkName(this, name, StarknetIdContract);
+  }
 }

src/provider/starknetId.ts

@@ -0,0 +1,64 @@
+import { BN } from 'bn.js';
+
+import { BigNumberish, hexToDecimalString, toBN, toHex } from '../utils/number';
+import { compileCalldata } from '../utils/stark';
+import { getStarknetIdContract, useDecoded, useEncoded } from '../utils/starknetId';
+import { ProviderInterface } from './interface';
+
+export async function getStarkName(
+  provider: ProviderInterface,
+  address: BigNumberish,
+  StarknetIdContract?: string
+): Promise<string> {
+  const chainId = await provider.getChainId();
+  const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
+
+  try {
+    const hexDomain = await provider.callContract({
+      contractAddress: contract,
+      entrypoint: 'address_to_domain',
+      calldata: compileCalldata({
+        address: toHex(toBN(address)),
+      }),
+    });
+    const decimalDomain = hexDomain.result
+      .map((element) => new BN(hexToDecimalString(element)))
+      .slice(1);
+
+    const stringDomain = useDecoded(decimalDomain);
+
+    if (!stringDomain) {
+      throw Error('Starkname not found');
+    }
+
+    return stringDomain;
+  } catch (e) {
+    if (e instanceof Error && e.message === 'Starkname not found') {
+      throw e;
+    }
+    throw Error('Could not get stark name');
+  }
+}
+
+export async function getAddressFromStarkName(
+  provider: ProviderInterface,
+  name: string,
+  StarknetIdContract?: string
+): Promise<string> {
+  const chainId = await provider.getChainId();
+  const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
+
+  try {
+    const addressData = await provider.callContract({
+      contractAddress: contract,
+      entrypoint: 'domain_to_address',
+      calldata: compileCalldata({
+        domain: [useEncoded(name.replace('.stark', '')).toString(10)],
+      }),
+    });
+
+    return addressData.result[0];
+  } catch {
+    throw Error('Could not get address from stark name');
+  }
+}

src/utils/starknetId.ts

@@ -52,6 +52,11 @@ export function useDecoded(encoded: BN[]): string {
           : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
     decoded += '.';
   });
+
+  if (!decoded) {
+    return decoded;
+  }
+
   return decoded.concat('stark');
 }