starknet 6.9.0 → 6.10.1

package/dist/utils/uint256.d.ts

@@ -0,0 +1,45 @@
+import { BigNumberish, Uint256 } from '../types';
+import { UINT_128_MAX, UINT_256_MAX } from './cairoDataTypes/uint256';
+/**
+ * @deprecated Legacy support Export
+ */
+export { UINT_128_MAX, UINT_256_MAX };
+/**
+ * Convert Uint256 to bigint
+ * Legacy support Export
+ * @param {Uint256} uint256 Uint256 value to convert to bigint
+ * @returns {bigint} BigInt representation of the input Uint256
+ * @example
+ * ```typescript
+ * const uint256Value: Uint256 = {low: 1234567890, high: 1};
+ * const result = uint256.uint256ToBN(uint256Value);
+ * // result = 340282366920938463463374607433002779346n
+ * ```
+ */
+export declare function uint256ToBN(uint256: Uint256): bigint;
+/**
+ * Test BigNumberish is in the range[0, 2**256-1]
+ * Legacy support Export
+ * @param {BigNumberish} bn value to test
+ * @returns {boolean} True if the input value is in the range[0, 2**256-1], false otherwise
+ * @example
+ * ```typescript
+ * const result = uint256.isUint256(12345n);
+ * // result = true
+ * const result1 = uint256.isUint256(-1);
+ * // result1 = false
+ * ```
+ */
+export declare function isUint256(bn: BigNumberish): boolean;
+/**
+ * Convert BigNumberish (string | number | bigint) to Uint256
+ * Legacy support Export
+ * @param {BigNumberish} bn value to convert to Uint256
+ * @returns {Uint256} Uint256 object representing the BigNumberish value
+ * @example
+ * ```typescript
+ * const result = uint256.bnToUint256(1000000000n);
+ * // result = {"low": "0x3b9aca00", "high": "0x0"}
+ * ```
+ */
+export declare function bnToUint256(bn: BigNumberish): Uint256;

package/dist/utils/uint256.mjs

@@ -0,0 +1,11 @@
+import { CairoUint256, UINT_128_MAX, UINT_256_MAX } from "./cairoDataTypes/uint256.mjs";
+export { UINT_128_MAX, UINT_256_MAX };
+export function uint256ToBN(uint256) {
+  return new CairoUint256(uint256).toBigInt();
+}
+export function isUint256(bn) {
+  return CairoUint256.is(bn);
+}
+export function bnToUint256(bn) {
+  return new CairoUint256(bn).toUint256HexString();
+}

package/dist/utils/url.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildUrl = buildUrl;
+exports.isUrl = isUrl;
+var _urlJoin = _interopRequireDefault(require("url-join"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+const localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+const nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
+function isUrl(s) {
+  if (!s) {
+    return false;
+  }
+  if (typeof s !== "string") {
+    return false;
+  }
+  const match = s.match(protocolAndDomainRE);
+  if (!match) {
+    return false;
+  }
+  const everythingAfterProtocol = match[1];
+  if (!everythingAfterProtocol) {
+    return false;
+  }
+  if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
+    return true;
+  }
+  return false;
+}
+function buildUrl(baseUrl, defaultPath, urlOrPath) {
+  return isUrl(urlOrPath) ? urlOrPath : (0, _urlJoin.default)(baseUrl, urlOrPath ?? defaultPath);
+}

package/dist/utils/url.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Loosely validate a URL `string`.
+ *
+ * @param {string} s - The URL to check for
+ * @return {boolean} `true` if url is valid, `false` otherwise
+ * @example
+ * ```typescript
+ * const s = "https://starknetjs.com/docs";
+ * const result = isUrl(s);
+ * // result == true
+ */
+export declare function isUrl(s?: string): boolean;
+/**
+ * Builds a URL using the provided base URL, default path, and optional URL or path.
+ *
+ * @param {string} baseUrl - The base URL of the URL being built.
+ * @param {string} defaultPath - The default path to use if no URL or path is provided.
+ * @param {string} [urlOrPath] - The optional URL or path to append to the base URL.
+ * @return {string} The built URL.
+ * @example
+ * ```typescript
+ * const baseUrl = "https://starknetjs.com";
+ * const defaultPath = "/";
+ * const urlOrPath = "/docs";
+ * const result = buildUrl(baseUrl, defaultPath, urlOrPath);
+ *
+ * result = "https://starknetjs.com/docs"
+ */
+export declare function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string): any;

package/dist/utils/url.mjs

@@ -0,0 +1,27 @@
+import urljoin from "url-join";
+const protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+const localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+const nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
+export function isUrl(s) {
+  if (!s) {
+    return false;
+  }
+  if (typeof s !== "string") {
+    return false;
+  }
+  const match = s.match(protocolAndDomainRE);
+  if (!match) {
+    return false;
+  }
+  const everythingAfterProtocol = match[1];
+  if (!everythingAfterProtocol) {
+    return false;
+  }
+  if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
+    return true;
+  }
+  return false;
+}
+export function buildUrl(baseUrl, defaultPath, urlOrPath) {
+  return isUrl(urlOrPath) ? urlOrPath : urljoin(baseUrl, urlOrPath ?? defaultPath);
+}

package/dist/wallet/account.cjs

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WalletAccount = void 0;
+var _account = require("../account/index.cjs");
+var _contract = require("../utils/contract.cjs");
+var _json = require("../utils/json.cjs");
+var _transaction = require("../utils/transaction.cjs");
+var _connect = require("./connect.cjs");
+class WalletAccount extends _account.Account {
+  address = "";
+  walletProvider;
+  constructor(providerOrOptions, walletProvider, cairoVersion) {
+    super(providerOrOptions, "", "", cairoVersion);
+    this.walletProvider = walletProvider;
+    this.walletProvider.on("accountsChanged", res => {
+      if (!res) return;
+      this.address = res[0].toLowerCase();
+    });
+    this.walletProvider.on("networkChanged", res => {
+      if (!res) return;
+      this.channel.setChainId(res);
+    });
+    walletProvider.request({
+      type: "wallet_requestAccounts",
+      params: {
+        silent_mode: false
+      }
+    }).then(res => {
+      this.address = res[0].toLowerCase();
+    });
+  }
+  /**
+   * WALLET EVENTS
+   */
+  onAccountChange(callback) {
+    (0, _connect.onAccountChange)(this.walletProvider, callback);
+  }
+  onNetworkChanged(callback) {
+    (0, _connect.onNetworkChanged)(this.walletProvider, callback);
+  }
+  /**
+   * WALLET SPECIFIC METHODS
+   */
+  requestAccounts(silentMode = false) {
+    return (0, _connect.requestAccounts)(this.walletProvider, silentMode);
+  }
+  getPermissions() {
+    return (0, _connect.getPermissions)(this.walletProvider);
+  }
+  switchStarknetChain(chainId) {
+    return (0, _connect.switchStarknetChain)(this.walletProvider, chainId);
+  }
+  watchAsset(asset) {
+    return (0, _connect.watchAsset)(this.walletProvider, asset);
+  }
+  addStarknetChain(chain) {
+    return (0, _connect.addStarknetChain)(this.walletProvider, chain);
+  }
+  /**
+   * ACCOUNT METHODS
+   */
+  execute(calls) {
+    const txCalls = [].concat(calls).map(it => {
+      const {
+        contractAddress,
+        entrypoint,
+        calldata
+      } = it;
+      return {
+        contract_address: contractAddress,
+        entry_point: entrypoint,
+        calldata
+      };
+    });
+    const params = {
+      calls: txCalls
+    };
+    return (0, _connect.addInvokeTransaction)(this.walletProvider, params);
+  }
+  declare(payload) {
+    const declareContractPayload = (0, _contract.extractContractHashes)(payload);
+    const pContract = payload.contract;
+    const cairo1Contract = {
+      ...pContract,
+      abi: (0, _json.stringify)(pContract.abi)
+    };
+    if (!declareContractPayload.compiledClassHash) {
+      throw Error("compiledClassHash is required");
+    }
+    const params = {
+      compiled_class_hash: declareContractPayload.compiledClassHash,
+      contract_class: cairo1Contract
+    };
+    return (0, _connect.addDeclareTransaction)(this.walletProvider, params);
+  }
+  async deploy(payload) {
+    const {
+      calls,
+      addresses
+    } = (0, _transaction.buildUDCCall)(payload, this.address);
+    const invokeResponse = await this.execute(calls);
+    return {
+      ...invokeResponse,
+      contract_address: addresses
+    };
+  }
+  signMessage(typedData) {
+    return (0, _connect.signMessage)(this.walletProvider, typedData);
+  }
+  // TODO: MISSING ESTIMATES
+}
+exports.WalletAccount = WalletAccount;

package/dist/wallet/account.d.ts

@@ -0,0 +1,31 @@
+import { type AccountChangeEventHandler, type AddStarknetChainParameters, type NetworkChangeEventHandler, type WatchAssetParameters, type SPEC } from 'starknet-types-07';
+import { Account, AccountInterface } from '../account';
+import { ProviderInterface } from '../provider';
+import { AllowArray, CairoVersion, Call, DeclareContractPayload, MultiDeployContractResponse, ProviderOptions, TypedData, UniversalDeployerContractPayload } from '../types';
+import { StarknetWalletProvider } from './types';
+import { StarknetChainId } from '../constants';
+export declare class WalletAccount extends Account implements AccountInterface {
+    address: string;
+    walletProvider: StarknetWalletProvider;
+    constructor(providerOrOptions: ProviderOptions | ProviderInterface, walletProvider: StarknetWalletProvider, cairoVersion?: CairoVersion);
+    /**
+     * WALLET EVENTS
+     */
+    onAccountChange(callback: AccountChangeEventHandler): void;
+    onNetworkChanged(callback: NetworkChangeEventHandler): void;
+    /**
+     * WALLET SPECIFIC METHODS
+     */
+    requestAccounts(silentMode?: boolean): Promise<string[]>;
+    getPermissions(): Promise<[] | "accounts"[]>;
+    switchStarknetChain(chainId: StarknetChainId): Promise<boolean>;
+    watchAsset(asset: WatchAssetParameters): Promise<boolean>;
+    addStarknetChain(chain: AddStarknetChainParameters): Promise<boolean>;
+    /**
+     * ACCOUNT METHODS
+     */
+    execute(calls: AllowArray<Call>): Promise<import("starknet-types-07").AddInvokeTransactionResult>;
+    declare(payload: DeclareContractPayload): Promise<import("starknet-types-07").AddDeclareTransactionResult>;
+    deploy(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[]): Promise<MultiDeployContractResponse>;
+    signMessage(typedData: TypedData): Promise<SPEC.SIGNATURE>;
+}

package/dist/wallet/account.mjs

@@ -0,0 +1,112 @@
+import { Account } from "../account/index.mjs";
+import { extractContractHashes } from "../utils/contract.mjs";
+import { stringify } from "../utils/json.mjs";
+import { buildUDCCall } from "../utils/transaction.mjs";
+import {
+  addDeclareTransaction,
+  addInvokeTransaction,
+  addStarknetChain,
+  getPermissions,
+  onAccountChange,
+  onNetworkChanged,
+  requestAccounts,
+  signMessage,
+  switchStarknetChain,
+  watchAsset
+} from "./connect.mjs";
+export class WalletAccount extends Account {
+  address = "";
+  walletProvider;
+  constructor(providerOrOptions, walletProvider, cairoVersion) {
+    super(providerOrOptions, "", "", cairoVersion);
+    this.walletProvider = walletProvider;
+    this.walletProvider.on("accountsChanged", (res) => {
+      if (!res) return;
+      this.address = res[0].toLowerCase();
+    });
+    this.walletProvider.on("networkChanged", (res) => {
+      if (!res) return;
+      this.channel.setChainId(res);
+    });
+    walletProvider.request({
+      type: "wallet_requestAccounts",
+      params: {
+        silent_mode: false
+      }
+    }).then((res) => {
+      this.address = res[0].toLowerCase();
+    });
+  }
+  /**
+   * WALLET EVENTS
+   */
+  onAccountChange(callback) {
+    onAccountChange(this.walletProvider, callback);
+  }
+  onNetworkChanged(callback) {
+    onNetworkChanged(this.walletProvider, callback);
+  }
+  /**
+   * WALLET SPECIFIC METHODS
+   */
+  requestAccounts(silentMode = false) {
+    return requestAccounts(this.walletProvider, silentMode);
+  }
+  getPermissions() {
+    return getPermissions(this.walletProvider);
+  }
+  switchStarknetChain(chainId) {
+    return switchStarknetChain(this.walletProvider, chainId);
+  }
+  watchAsset(asset) {
+    return watchAsset(this.walletProvider, asset);
+  }
+  addStarknetChain(chain) {
+    return addStarknetChain(this.walletProvider, chain);
+  }
+  /**
+   * ACCOUNT METHODS
+   */
+  execute(calls) {
+    const txCalls = [].concat(calls).map((it) => {
+      const { contractAddress, entrypoint, calldata } = it;
+      return {
+        contract_address: contractAddress,
+        entry_point: entrypoint,
+        calldata
+      };
+    });
+    const params = {
+      calls: txCalls
+    };
+    return addInvokeTransaction(this.walletProvider, params);
+  }
+  declare(payload) {
+    const declareContractPayload = extractContractHashes(payload);
+    const pContract = payload.contract;
+    const cairo1Contract = {
+      ...pContract,
+      abi: stringify(pContract.abi)
+    };
+    if (!declareContractPayload.compiledClassHash) {
+      throw Error("compiledClassHash is required");
+    }
+    const params = {
+      compiled_class_hash: declareContractPayload.compiledClassHash,
+      contract_class: cairo1Contract
+    };
+    return addDeclareTransaction(this.walletProvider, params);
+  }
+  async deploy(payload) {
+    const { calls, addresses } = buildUDCCall(payload, this.address);
+    const invokeResponse = await this.execute(calls);
+    return {
+      ...invokeResponse,
+      contract_address: addresses
+    };
+  }
+  signMessage(typedData) {
+    return signMessage(this.walletProvider, typedData);
+  }
+  // TODO: MISSING ESTIMATES
+}

package/dist/wallet/connect.cjs

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDeclareTransaction = addDeclareTransaction;
+exports.addInvokeTransaction = addInvokeTransaction;
+exports.addStarknetChain = addStarknetChain;
+exports.deploymentData = deploymentData;
+exports.getPermissions = getPermissions;
+exports.onAccountChange = onAccountChange;
+exports.onNetworkChanged = onNetworkChanged;
+exports.requestAccounts = requestAccounts;
+exports.requestChainId = requestChainId;
+exports.signMessage = signMessage;
+exports.supportedSpecs = supportedSpecs;
+exports.switchStarknetChain = switchStarknetChain;
+exports.watchAsset = watchAsset;
+function requestAccounts(swo, silent_mode = false) {
+  return swo.request({
+    type: "wallet_requestAccounts",
+    params: {
+      silent_mode
+    }
+  });
+}
+function getPermissions(swo) {
+  return swo.request({
+    type: "wallet_getPermissions"
+  });
+}
+function watchAsset(swo, asset) {
+  return swo.request({
+    type: "wallet_watchAsset",
+    params: asset
+  });
+}
+function addStarknetChain(swo, chain) {
+  return swo.request({
+    type: "wallet_addStarknetChain",
+    params: chain
+  });
+}
+function switchStarknetChain(swo, chainId) {
+  return swo.request({
+    type: "wallet_switchStarknetChain",
+    params: {
+      chainId
+    }
+  });
+}
+function requestChainId(swo) {
+  return swo.request({
+    type: "wallet_requestChainId"
+  });
+}
+function deploymentData(swo) {
+  return swo.request({
+    type: "wallet_deploymentData"
+  });
+}
+function addInvokeTransaction(swo, params) {
+  return swo.request({
+    type: "wallet_addInvokeTransaction",
+    params
+  });
+}
+function addDeclareTransaction(swo, params) {
+  return swo.request({
+    type: "wallet_addDeclareTransaction",
+    params
+  });
+}
+function signMessage(swo, typedData) {
+  return swo.request({
+    type: "wallet_signTypedData",
+    params: typedData
+  });
+}
+function supportedSpecs(swo) {
+  return swo.request({
+    type: "wallet_supportedSpecs"
+  });
+}
+function onAccountChange(swo, callback) {
+  swo.on("accountsChanged", callback);
+}
+function onNetworkChanged(swo, callback) {
+  swo.on("networkChanged", callback);
+}

package/dist/wallet/connect.d.ts

@@ -0,0 +1,82 @@
+import { type WatchAssetParameters, type AccountChangeEventHandler, type AddDeclareTransactionParameters, type AddInvokeTransactionParameters, type AddStarknetChainParameters, type NetworkChangeEventHandler, type ChainId, type StarknetWindowObject, type TypedData, type SPEC } from 'starknet-types-07';
+/**
+ * Request Permission for wallet account, return addresses that are allowed by user
+ * @param {boolean} [silent_mode=false] false: request user interaction allowance. true: return only pre-allowed
+ * @returns allowed accounts addresses
+ */
+export declare function requestAccounts(swo: StarknetWindowObject, silent_mode?: boolean): Promise<string[]>;
+/**
+ * Request Permission for wallet account
+ * @returns allowed accounts addresses
+ */
+export declare function getPermissions(swo: StarknetWindowObject): Promise<[] | "accounts"[]>;
+/**
+ * Request adding ERC20 Token to Wallet List
+ * @param asset WatchAssetParameters
+ * @returns boolean
+ */
+export declare function watchAsset(swo: StarknetWindowObject, asset: WatchAssetParameters): Promise<boolean>;
+/**
+ * Request adding custom Starknet chain
+ * @param chain AddStarknetChainParameters
+ * @returns boolean
+ */
+export declare function addStarknetChain(swo: StarknetWindowObject, chain: AddStarknetChainParameters): Promise<boolean>;
+/**
+ * Request Wallet Network change
+ * @param chainId StarknetChainId
+ * @returns boolean
+ */
+export declare function switchStarknetChain(swo: StarknetWindowObject, chainId: ChainId): Promise<boolean>;
+/**
+ * Request the current chain ID from the wallet.
+ * @returns The current Starknet chain ID.
+ */
+export declare function requestChainId(swo: StarknetWindowObject): Promise<string>;
+/**
+ * Get deployment data for a contract.
+ * @returns The deployment data result.
+ */
+export declare function deploymentData(swo: StarknetWindowObject): Promise<import("starknet-types-07").AccountDeploymentData>;
+/**
+ * Add an invoke transaction to the wallet.
+ * @param params The parameters required for the invoke transaction.
+ * @returns The result of adding the invoke transaction.
+ */
+export declare function addInvokeTransaction(swo: StarknetWindowObject, params: AddInvokeTransactionParameters): Promise<import("starknet-types-07").AddInvokeTransactionResult>;
+/**
+ * Add a declare transaction to the wallet.
+ * @param params The parameters required for the declare transaction.
+ * @returns The result of adding the declare transaction.
+ */
+export declare function addDeclareTransaction(swo: StarknetWindowObject, params: AddDeclareTransactionParameters): Promise<import("starknet-types-07").AddDeclareTransactionResult>;
+/**
+ * Sign typed data using the wallet.
+ * @param swo the starknet (wallet) window object to request the signature.
+ * @param typedData The typed data to sign.
+ * @returns An array of signatures as strings.
+ */
+export declare function signMessage(swo: StarknetWindowObject, typedData: TypedData): Promise<SPEC.SIGNATURE>;
+/**
+ * Get the list of supported specifications.
+ * @returns An array of supported specification strings.
+ */
+export declare function supportedSpecs(swo: StarknetWindowObject): Promise<string[]>;
+/**
+ * Attaches an event handler function to the "accountsChanged" event of a StarknetWindowObject.
+ * When the accounts are changed, the specified callback function will be called.
+ *
+ * @param {StarknetWindowObject} swo - The StarknetWindowObject to attach the event handler to.
+ * @param {AccountChangeEventHandler} callback - The function to be called when the accounts are changed.
+ *                                              It will receive the changed accounts as a parameter.
+ * @returns {void}
+ */
+export declare function onAccountChange(swo: StarknetWindowObject, callback: AccountChangeEventHandler): void;
+/**
+ * Register a callback function to be called when the network is changed.
+ *
+ * @param {StarknetWindowObject} swo - The StarknetWindowObject instance.
+ * @param {NetworkChangeEventHandler} callback - The callback function to be called when the network is changed.
+ * @return {void}
+ */
+export declare function onNetworkChanged(swo: StarknetWindowObject, callback: NetworkChangeEventHandler): void;

package/dist/wallet/connect.mjs

@@ -0,0 +1,64 @@
+export function requestAccounts(swo, silent_mode = false) {
+  return swo.request({
+    type: "wallet_requestAccounts",
+    params: {
+      silent_mode
+    }
+  });
+}
+export function getPermissions(swo) {
+  return swo.request({ type: "wallet_getPermissions" });
+}
+export function watchAsset(swo, asset) {
+  return swo.request({
+    type: "wallet_watchAsset",
+    params: asset
+  });
+}
+export function addStarknetChain(swo, chain) {
+  return swo.request({
+    type: "wallet_addStarknetChain",
+    params: chain
+  });
+}
+export function switchStarknetChain(swo, chainId) {
+  return swo.request({
+    type: "wallet_switchStarknetChain",
+    params: {
+      chainId
+    }
+  });
+}
+export function requestChainId(swo) {
+  return swo.request({ type: "wallet_requestChainId" });
+}
+export function deploymentData(swo) {
+  return swo.request({ type: "wallet_deploymentData" });
+}
+export function addInvokeTransaction(swo, params) {
+  return swo.request({
+    type: "wallet_addInvokeTransaction",
+    params
+  });
+}
+export function addDeclareTransaction(swo, params) {
+  return swo.request({
+    type: "wallet_addDeclareTransaction",
+    params
+  });
+}
+export function signMessage(swo, typedData) {
+  return swo.request({
+    type: "wallet_signTypedData",
+    params: typedData
+  });
+}
+export function supportedSpecs(swo) {
+  return swo.request({ type: "wallet_supportedSpecs" });
+}
+export function onAccountChange(swo, callback) {
+  swo.on("accountsChanged", callback);
+}
+export function onNetworkChanged(swo, callback) {
+  swo.on("networkChanged", callback);
+}

package/dist/wallet/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _account = require("./account.cjs");
+Object.keys(_account).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _account[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _account[key];
+    }
+  });
+});

package/dist/wallet/index.d.ts

@@ -0,0 +1 @@
+export * from './account';

package/dist/wallet/index.mjs

@@ -0,0 +1 @@
+export * from "./account.mjs";

package/dist/wallet/types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/wallet/types.d.ts

@@ -0,0 +1,4 @@
+import { type RpcMessage, type StarknetWindowObject } from 'starknet-types-07';
+export type RpcCall = Omit<RpcMessage, 'result'>;
+export interface StarknetWalletProvider extends StarknetWindowObject {
+}