@stacks/clarinet-sdk-wasm 3.8.1

package/README.md

@@ -0,0 +1,51 @@
+# Clarity SDK WASM
+
+This component exposes Clarinet features to a JS interface through wasm-bindgen. It's built with
+wasm-pack.  
+It powers [@stacks/clarinet-sdk](https://npmjs.com/package/@stacks/clarinet-sdk) and
+[@stacks/clarinet-sdk-browser](https://npmjs.com/package/@stacks/clarinet-sdk-browser).
+
+## Contributing
+
+### Build package
+
+Install [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/).
+
+In the root directory of Clarinet, run the following command to build the packages for Node.js and
+the browser. Under the hood, it will run `wasm-pack build` twice, once for each target.
+
+```sh
+npm run build:sdk-wasm
+```
+
+Alternatively, it's also possible to build the packages separately. It should only be done for
+development purpose.
+
+**Build for node**
+
+```sh
+wasm-pack build --release --scope stacks --out-dir pkg-node --target nodejs
+```
+
+**Build for the browser**
+
+```sh
+wasm-pack build --release --scope stacks --out-dir pkg-browser --target web
+```
+
+### Release
+
+The package is built twice with `wasm-pack` as it can't target `node` and `web` at the same time.
+The following script will build for both target, it will also rename the package name for the
+browser build.
+
+```sh
+npm run build:sdk-wasm
+```
+
+Once built, the packages can be released by running the following command. Note that by default we
+release with the beta tag.
+
+```sh
+npm run publish:sdk-wasm
+```

package/clarinet_sdk.d.ts

@@ -0,0 +1,227 @@
+/* tslint:disable */
+/* eslint-disable */
+export type EpochString =
+  | "2.0"
+  | "2.05"
+  | "2.1"
+  | "2.2"
+  | "2.3"
+  | "2.4"
+  | "2.5"
+  | "3.0"
+  | "3.1"
+  | "3.2"
+  | "3.3";
+
+
+type Atom = {
+  Atom: String;
+};
+
+type AtomValue = {
+  AtomValue: any;
+};
+
+type List = {
+  List: Expression[];
+};
+
+type LiteralValue = {
+  LiteralValue: any;
+};
+
+type Field = {
+  Field: any;
+};
+
+type TraitReference = {
+  TraitReference: any;
+};
+
+type ExpressionType = Atom | AtomValue | List | LiteralValue | Field | TraitReference;
+
+type Span = {
+  start_line: number;
+  start_column: number;
+  end_line: number;
+  end_column: number;
+};
+
+type Expression = {
+  expr: ExpressionType;
+  id: number;
+  span: Span;
+};
+
+type IContractAST = {
+  contract_identifier: any;
+  pre_expressions: any[];
+  expressions: Expression[];
+  top_level_expression_sorting: number[];
+  referenced_traits: Map<any, any>;
+  implemented_traits: any[];
+};
+
+type ContractInterfaceFunctionAccess = "private" | "public" | "read_only";
+
+type ContractInterfaceTupleEntryType = { name: string; type: ContractInterfaceAtomType };
+
+type ContractInterfaceAtomType =
+  | "none"
+  | "int128"
+  | "uint128"
+  | "bool"
+  | "principal"
+  | { buffer: { length: number } }
+  | { "string-utf8": { length: number } }
+  | { "string-ascii": { length: number } }
+  | { tuple: ContractInterfaceTupleEntryType[] }
+  | { optional: ContractInterfaceAtomType }
+  | { response: { ok: ContractInterfaceAtomType; error: ContractInterfaceAtomType } }
+  | { list: { type: ContractInterfaceAtomType; length: number } }
+  | "trait_reference";
+
+type ContractInterfaceFunctionArg = { name: string; type: ContractInterfaceAtomType };
+
+type ContractInterfaceFunctionOutput = { type: ContractInterfaceAtomType };
+
+type ContractInterfaceFunction = {
+  name: string;
+  access: ContractInterfaceFunctionAccess;
+  args: ContractInterfaceFunctionArg[];
+  outputs: ContractInterfaceFunctionOutput;
+};
+
+type ContractInterfaceVariableAccess = "constant" | "variable";
+
+type ContractInterfaceVariable = {
+  name: string;
+  type: ContractInterfaceAtomType;
+  access: ContractInterfaceVariableAccess;
+};
+
+type ContractInterfaceMap = {
+  name: string;
+  key: ContractInterfaceAtomType;
+  value: ContractInterfaceAtomType;
+};
+
+type ContractInterfaceFungibleTokens = { name: string };
+
+type ContractInterfaceNonFungibleTokens = { name: string; type: ContractInterfaceAtomType };
+
+export type StacksEpochId =
+  | "Epoch10"
+  | "Epoch20"
+  | "Epoch2_05"
+  | "Epoch21"
+  | "Epoch22"
+  | "Epoch23"
+  | "Epoch24"
+  | "Epoch25"
+  | "Epoch30"
+  | "Epoch31"
+  | "Epoch32"
+  | "Epoch33";
+
+export type ClarityVersionString = "Clarity1" | "Clarity2" | "Clarity3"| "Clarity4";
+
+export type IContractInterface = {
+  functions: ContractInterfaceFunction[];
+  variables: ContractInterfaceVariable[];
+  maps: ContractInterfaceMap[];
+  fungible_tokens: ContractInterfaceFungibleTokens[];
+  non_fungible_tokens: ContractInterfaceNonFungibleTokens[];
+  epoch: StacksEpochId;
+  clarity_version: ClarityVersionString;
+};
+
+export class CallFnArgs {
+  free(): void;
+  constructor(contract: string, method: string, args: Uint8Array[], sender: string);
+}
+export class ContractOptions {
+  free(): void;
+  constructor(clarity_version?: number | null);
+}
+export class DeployContractArgs {
+  free(): void;
+  constructor(name: string, content: string, options: ContractOptions, sender: string);
+}
+export class SDK {
+  free(): void;
+  constructor(fs_request: Function, options?: SDKOptions | null);
+  static getDefaultEpoch(): EpochString;
+  getDefaultClarityVersionForCurrentEpoch(): ClarityVersionString;
+  initEmptySession(remote_data_settings: any): Promise<void>;
+  initSession(cwd: string, manifest_path: string): Promise<void>;
+  clearCache(): void;
+  setEpoch(epoch: EpochString): void;
+  getContractsInterfaces(): Map<string, IContractInterface>;
+  getContractSource(contract: string): string | undefined;
+  getContractAST(contract: string): IContractAST;
+  getAssetsMap(): Map<string, Map<string, bigint>>;
+  getAccounts(): Map<string, string>;
+  getDataVar(contract: string, var_name: string): string;
+  getBlockTime(): bigint;
+  getMapEntry(contract: string, map_name: string, map_key: Uint8Array): string;
+  callReadOnlyFn(args: CallFnArgs): TransactionRes;
+  deployContract(args: DeployContractArgs): TransactionRes;
+  transferSTX(args: TransferSTXArgs): TransactionRes;
+  callPublicFn(args: CallFnArgs): TransactionRes;
+  callPrivateFn(args: CallFnArgs): TransactionRes;
+  mineBlock(js_txs: Array<any>): any;
+  mineEmptyBlock(): number;
+  mineEmptyBlocks(count?: number | null): number;
+  mineEmptyStacksBlock(): number;
+  mineEmptyStacksBlocks(count?: number | null): number;
+  mineEmptyBurnBlock(): number;
+  mineEmptyBurnBlocks(count?: number | null): number;
+  runSnippet(snippet: string): string;
+  execute(snippet: string): TransactionRes;
+  executeCommand(snippet: string): string;
+  /**
+   * Returns the last contract call trace as a string, if available.
+   */
+  getLastContractCallTrace(): string | undefined;
+  setLocalAccounts(addresses: string[]): void;
+  mintSTX(recipient: string, amount: bigint): string;
+  setCurrentTestName(test_name: string): void;
+  collectReport(include_boot_contracts: boolean, boot_contracts_path: string): SessionReport;
+  enablePerformance(cost_field: string): void;
+  deployer: string;
+  readonly blockHeight: number;
+  readonly stacksBlockHeight: number;
+  readonly burnBlockHeight: number;
+  readonly currentEpoch: string;
+}
+export class SDKOptions {
+  free(): void;
+  constructor(track_costs: boolean, track_coverage: boolean, track_performance?: boolean | null);
+  trackCosts: boolean;
+  trackCoverage: boolean;
+  trackPerformance: boolean;
+}
+export class SessionReport {
+  private constructor();
+  free(): void;
+  coverage: string;
+  costs: string;
+}
+export class TransactionRes {
+  private constructor();
+  free(): void;
+  result: string;
+  events: string;
+  costs: string;
+  get performance(): string | undefined;
+  set performance(value: string | null | undefined);
+}
+export class TransferSTXArgs {
+  free(): void;
+  constructor(amount: bigint, recipient: string, sender: string);
+}
+export class TxArgs {
+  private constructor();
+  free(): void;
+}