@heyanon/sdk 2.4.0 → 2.4.1

package/dist/index.mjs

@@ -633,6 +633,592 @@ function normalizeAddress(chain, address) {
   return address;
 }
 
+// src/utils/messages-releaser.ts
+var MessagesReleaser = class {
+  constructor(opts = {}) {
+    this._messages = [];
+    this._separator = "\n";
+    if (opts?.separator) {
+      this._separator = opts.separator;
+    }
+  }
+  get separator() {
+    return this._separator;
+  }
+  get messages() {
+    return this._messages;
+  }
+  release(lastMessage) {
+    if (lastMessage) {
+      this.add(lastMessage);
+    }
+    const message = this._messages.length > 0 ? this._separator.concat(this._messages.join(this._separator)) : "";
+    this.reset();
+    return message;
+  }
+  add(...msgs) {
+    this._messages.push(...msgs);
+  }
+  reset() {
+    this._messages = [];
+  }
+};
+
+// src/utils/try-steps-executor.ts
+var TryStepsExecutor = class {
+  constructor(initialReleaser, initialOnFailureFn) {
+    this.msgsReleaser = initialReleaser || new MessagesReleaser();
+    this.onFailureFn = initialOnFailureFn;
+  }
+  async executeStep(executeFn, onSuccessMessage, onFailureMessage) {
+    try {
+      const result = await executeFn();
+      this.msgsReleaser.add(onSuccessMessage);
+      return result;
+    } catch (error) {
+      await this.onFailureFn(onFailureMessage);
+      throw error;
+    }
+  }
+};
+
+// src/utils/workflow-retry.ts
+var WorkflowBreakError = class extends Error {
+  /**
+   * Create a new WorkflowBreakError
+   * @param breakReason Optional reason for breaking the workflow
+   */
+  constructor(breakReason) {
+    super("Workflow execution was interrupted");
+    this.name = "WorkflowBreakError";
+    this.breakReason = breakReason;
+  }
+};
+var WorkflowAction = class {
+  /**
+   * Create a new WorkflowAction
+   * @param options Action configuration
+   */
+  constructor(options) {
+    /**
+     * Current attempt number
+     */
+    this.currentAttempt = 0;
+    this.name = options.name;
+    this.action = options.action;
+    this.attempts = options.attempts || 1;
+    this.delayMs = options.delayMs || 0;
+    this.onRetry = options.onRetry;
+    this.onSuccess = options.onSuccess;
+    this.onFailed = options.onFailed;
+  }
+  /**
+   * Get the name of the action
+   * @returns The name of the action
+   */
+  getName() {
+    return this.name;
+  }
+  /**
+   * Private retry method for action execution
+   * @param fn The function to retry
+   * @param context The workflow context
+   * @returns Promise with the result of the function
+   * @throws {Error} If all retry attempts fail
+   */
+  async retry(fn, context) {
+    for (let attempt = 1; attempt <= this.attempts; attempt++) {
+      try {
+        this.currentAttempt = attempt;
+        return await fn();
+      } catch (error) {
+        if (error instanceof WorkflowBreakError) {
+          throw error;
+        }
+        if (attempt < this.attempts && this.onRetry) {
+          try {
+            await this.onRetry(this.currentAttempt, error, context);
+          } catch (error2) {
+            if (error2 instanceof WorkflowBreakError) {
+              context.getWorkflow().break(context.getWorkflow().getBreakReason());
+            } else {
+              context.getWorkflow().break(error2);
+            }
+          }
+        }
+        if (attempt === this.attempts) {
+          throw error;
+        }
+        if (this.delayMs >= 0) {
+          this.delayMs === 0 ? await new Promise((resolve) => setImmediate(resolve, this.delayMs)) : await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+        }
+      }
+    }
+    throw new Error(`Failed to execute action ${this.name} after ${this.attempts} attempts`);
+  }
+  /**
+   * Execute the action with retry logic
+   * @param context The workflow context containing results from previous actions
+   * @returns Promise with the result of the action
+   * @throws {Error} If all retry attempts fail
+   * @throws {WorkflowBreakError} If the workflow is broken
+   */
+  async execute(context) {
+    try {
+      return await this.retry(async () => {
+        const result = await this.action(context);
+        if (this.onSuccess) {
+          try {
+            await this.onSuccess(this.currentAttempt, result, context);
+          } catch (error) {
+            if (error instanceof WorkflowBreakError) {
+              context.getWorkflow().break(context.getWorkflow().getBreakReason());
+            } else {
+              context.getWorkflow().break(error);
+            }
+          }
+        }
+        return result;
+      }, context);
+    } catch (error) {
+      if (error instanceof WorkflowBreakError) {
+        throw error;
+      }
+      if (this.onFailed) {
+        try {
+          await this.onFailed(this.currentAttempt, error, context);
+        } catch (error2) {
+          if (error2 instanceof WorkflowBreakError) {
+            context.getWorkflow().break(context.getWorkflow().getBreakReason());
+          } else {
+            context.getWorkflow().break(error2);
+          }
+        }
+      }
+      throw error;
+    }
+  }
+};
+var WorkflowContext = class {
+  /**
+   * Create a new WorkflowContext
+   * @param workflow The workflow instance
+   */
+  constructor(workflow) {
+    /**
+     * Results from previous actions, stored by name
+     */
+    this.resultsByName = /* @__PURE__ */ new Map();
+    /**
+     * Results from previous actions, stored by index
+     */
+    this.resultsByIndex = [];
+    /**
+     * Current attempt number
+     */
+    this.currentAttempt = 0;
+    /**
+     * Current action name
+     */
+    this.currentActionName = "";
+    this.workflow = workflow;
+  }
+  /**
+   * Get the current attempt number
+   * @returns The current attempt number (1-based)
+   */
+  getAttempt() {
+    return this.currentAttempt;
+  }
+  /**
+   * Set the current attempt number
+   * @param attempt The attempt number to set
+   */
+  setAttempt(attempt) {
+    this.currentAttempt = attempt;
+  }
+  /**
+   * Get the current action name
+   * @returns The name of the currently executed action
+   */
+  getActionName() {
+    return this.currentActionName;
+  }
+  /**
+   * Set the current action name
+   * @param name The name of the action to set
+   */
+  setActionName(name) {
+    this.currentActionName = name;
+  }
+  /**
+   * Get the result of a specific action by name
+   * @param name The name of the action result to retrieve
+   * @returns The result of the action with the specified name
+   * @throws {Error} If no result is available with the specified name
+   */
+  getResultByName(name) {
+    if (!this.resultsByName.has(name)) {
+      throw new Error(`No result available with name "${name}"`);
+    }
+    return this.resultsByName.get(name);
+  }
+  /**
+   * Get all results from previous actions
+   * @returns Array of all results
+   */
+  getAllResults() {
+    return [...this.resultsByIndex];
+  }
+  /**
+   * Add a result to the context
+   * @param name The name of the action
+   * @param result The result to add
+   */
+  addResult(name, result) {
+    this.resultsByName.set(name, result);
+    this.resultsByIndex.push(result);
+  }
+  /**
+   * Get the results by name
+   * @returns Map of results by name
+   */
+  getResultsByName() {
+    return this.resultsByName;
+  }
+  /**
+   * Get the workflow instance
+   * @returns The workflow instance
+   */
+  getWorkflow() {
+    return this.workflow;
+  }
+};
+var WorkflowResult = class {
+  /**
+   * Create a new WorkflowResult
+   * @param results Array of results from actions
+   * @param actionNames Array of action names corresponding to the results
+   */
+  constructor(results = [], actionNames = []) {
+    /**
+     * Results from actions, stored by name
+     */
+    this.resultsByName = /* @__PURE__ */ new Map();
+    /**
+     * Results from actions, stored by index
+     */
+    this.resultsByIndex = [];
+    /**
+     * Failures from actions, stored by action name and attempt number
+     */
+    this.failuresByAction = /* @__PURE__ */ new Map();
+    this.resultsByIndex = [...results];
+    actionNames.forEach((name, index) => {
+      if (index < results.length) {
+        this.resultsByName.set(name, results[index]);
+      }
+    });
+  }
+  /**
+   * Add a result to the workflow result
+   * @param name The name of the action
+   * @param result The result to add
+   */
+  addResult(name, result) {
+    this.resultsByName.set(name, result);
+    this.resultsByIndex.push(result);
+  }
+  /**
+   * Add a failure to the workflow result
+   * @param name The name of the action that failed
+   * @param attempt The attempt number
+   * @param reason The reason for the failure
+   */
+  addFailure(name, attempt, reason) {
+    if (!this.failuresByAction.has(name)) {
+      this.failuresByAction.set(name, /* @__PURE__ */ new Map());
+    }
+    this.failuresByAction.get(name).set(attempt, reason);
+  }
+  /**
+   * Get all failures for a specific action
+   * @param name The name of the action
+   * @returns Map of attempt numbers to failure reasons
+   */
+  getFailuresByAction(name) {
+    return this.failuresByAction.get(name) || /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all failures across all actions
+   * @returns Map of action names to maps of attempt numbers to failure reasons
+   */
+  getAllFailures() {
+    return new Map(this.failuresByAction);
+  }
+  /**
+   * Check if an action failed in a specific attempt
+   * @param name The name of the action
+   * @param attempt The attempt number
+   * @returns True if the action failed in the specified attempt
+   */
+  hasFailure(name, attempt) {
+    return this.failuresByAction.has(name) && this.failuresByAction.get(name).has(attempt);
+  }
+  /**
+   * Get the failure reason for an action in a specific attempt
+   * @param name The name of the action
+   * @param attempt The attempt number
+   * @returns The failure reason or undefined if no failure occurred
+   */
+  getFailure(name, attempt) {
+    return this.failuresByAction.get(name)?.get(attempt);
+  }
+  /**
+   * Get all attempts when an action failed
+   * @param name The name of the action
+   * @returns Array of attempt numbers
+   */
+  getFailureAttempts(name) {
+    if (!this.failuresByAction.has(name)) {
+      return [];
+    }
+    return Array.from(this.failuresByAction.get(name).keys());
+  }
+  /**
+   * Get all actions that failed
+   * @returns Array of action names
+   */
+  getFailedActions() {
+    return Array.from(this.failuresByAction.keys());
+  }
+  /**
+   * Get all actions that failed with a specific reason
+   * @param reason The failure reason to search for
+   * @returns Array of action names
+   */
+  getActionsFailedWithReason(reason) {
+    const failedActions = [];
+    this.failuresByAction.forEach((attemptFailures, name) => {
+      attemptFailures.forEach((failureReason) => {
+        if (this.areReasonsEqual(failureReason, reason)) {
+          failedActions.push(name);
+        }
+      });
+    });
+    return [...new Set(failedActions)];
+  }
+  /**
+   * Compare two reasons for equality
+   * @param reason1 First reason
+   * @param reason2 Second reason
+   * @returns True if the reasons are equal
+   * @private
+   */
+  areReasonsEqual(reason1, reason2) {
+    if (reason1 instanceof Error && reason2 instanceof Error) {
+      return reason1.message === reason2.message;
+    }
+    if (typeof reason1 === "string" && typeof reason2 === "string") {
+      return reason1 === reason2;
+    }
+    try {
+      return JSON.stringify(reason1) === JSON.stringify(reason2);
+    } catch {
+      return String(reason1) === String(reason2);
+    }
+  }
+  /**
+   * Get the result of a specific action by name
+   * @param name The name of the action
+   * @returns The result of the action with the specified name
+   * @throws {Error} If no result is available with the specified name
+   */
+  getResult(name) {
+    if (!this.resultsByName.has(name)) {
+      throw new Error(`No result available with name "${name}"`);
+    }
+    return this.resultsByName.get(name);
+  }
+  /**
+   * Get the result of the last action in the workflow
+   * @returns The result of the last action
+   * @throws {Error} If no results are available
+   */
+  getLastActionResult() {
+    if (this.resultsByIndex.length === 0) {
+      throw new Error("No results available");
+    }
+    return this.resultsByIndex[this.resultsByIndex.length - 1];
+  }
+  /**
+   * Get all results from the workflow
+   * @returns Array of all results
+   */
+  getAllResults() {
+    return [...this.resultsByIndex];
+  }
+  /**
+   * Get the number of results
+   * @returns The number of results
+   */
+  getResultCount() {
+    return this.resultsByIndex.length;
+  }
+};
+var WorkflowRetry = class {
+  /**
+   * Create a new WorkflowRetry instance
+   * @param options Configuration options for the workflow and actions
+   */
+  constructor(options = {}) {
+    /**
+     * List of actions to execute in the workflow
+     */
+    this.actions = [];
+    /**
+     * Flag indicating if the workflow was broken
+     */
+    this.isBroken = false;
+    this.attempts = options.attempts || 1;
+    this.delayMs = options.delayMs || 0;
+    this.onBreak = options.onBreak;
+    this.onSuccess = options.onSuccess;
+    this.onFailed = options.onFailed;
+    this.onRetry = options.onRetry;
+  }
+  /**
+   * Break the workflow execution with an error
+   * @param reason Optional reason for breaking the workflow
+   * @param customError Optional custom error to throw instead of WorkflowBreakError
+   * @throws {WorkflowBreakError} Always throws to break the workflow
+   */
+  break(reason) {
+    this.isBroken = true;
+    this.breakReason = reason;
+    throw new WorkflowBreakError();
+  }
+  /**
+   * Check if the workflow was broken
+   * @returns True if the workflow was broken
+   */
+  wasBroken() {
+    return this.isBroken;
+  }
+  /**
+   * Get the reason for breaking the workflow
+   * @returns The reason for breaking the workflow
+   */
+  getBreakReason() {
+    return this.breakReason;
+  }
+  /**
+   * Add an action to the workflow
+   * @param options Action options including the action function and retry configuration
+   * @returns The WorkflowRetry instance for method chaining
+   */
+  addAction(options) {
+    const workflowAction = new WorkflowAction(options);
+    this.actions.push(workflowAction);
+    return this;
+  }
+  /**
+   * Private retry method for workflow execution
+   * @param fn The function to retry
+   * @param context The workflow context
+   * @returns Promise with the result of the function
+   * @throws {Error} If all retry attempts fail
+   */
+  async retry(fn, context) {
+    for (let attempt = 1; attempt <= this.attempts; attempt++) {
+      try {
+        context.setAttempt(attempt);
+        return await fn();
+      } catch (error) {
+        if (error instanceof WorkflowBreakError) {
+          throw error;
+        }
+        if (attempt < this.attempts && this.onRetry) {
+          try {
+            await this.onRetry(error, context);
+          } catch (error2) {
+            if (error2 instanceof WorkflowBreakError) {
+              this.break(this.breakReason);
+            } else {
+              this.break(error2);
+            }
+          }
+        }
+        if (attempt === this.attempts) {
+          throw error;
+        }
+        if (this.delayMs >= 0) {
+          this.delayMs === 0 ? await new Promise((resolve) => setImmediate(resolve, this.delayMs)) : await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+        }
+      }
+    }
+    throw new Error(`Failed to execute workflow after ${this.attempts} attempts`);
+  }
+  /**
+   * Execute all actions in the workflow with retry logic
+   * @returns Promise with a WorkflowResult object containing the results
+   * @throws {Error} If any action fails after all retry attempts
+   * @throws {WorkflowBreakError} If the workflow is broken
+   */
+  async execute() {
+    const context = new WorkflowContext(this);
+    this.isBroken = false;
+    try {
+      return await this.retry(async () => {
+        const workflowResult = new WorkflowResult();
+        for (const action of this.actions) {
+          context.setActionName(action.getName());
+          const actionResult = await action.execute(context);
+          workflowResult.addResult(action.getName(), actionResult);
+          context.addResult(action.getName(), actionResult);
+        }
+        if (this.onSuccess) {
+          try {
+            await this.onSuccess(context);
+          } catch (error) {
+            if (error instanceof WorkflowBreakError) {
+              this.break(this.breakReason);
+            } else {
+              this.break(error);
+            }
+          }
+        }
+        return workflowResult;
+      }, context);
+    } catch (error) {
+      if (this.onBreak && error instanceof WorkflowBreakError) {
+        try {
+          await this.onBreak(this.breakReason, context);
+        } catch (error2) {
+          if (error2 instanceof WorkflowBreakError && this.breakReason instanceof Error) {
+            throw this.breakReason;
+          }
+          throw error2;
+        }
+      }
+      if (error instanceof WorkflowBreakError && this.breakReason instanceof Error) {
+        throw this.breakReason;
+      }
+      if (this.onFailed && !(error instanceof WorkflowBreakError)) {
+        try {
+          await this.onFailed(error, context);
+        } catch (error2) {
+          if (error2 instanceof WorkflowBreakError && this.breakReason instanceof Error) {
+            throw this.breakReason;
+          }
+          throw error2;
+        }
+      }
+      throw error;
+    }
+  }
+};
+
 // src/adapter/transformers/toResult.ts
 function toResult(data, error = false) {
   const formatedData = typeof data === "string" ? data : stringify(data);
@@ -659,4 +1245,4 @@ var AdapterTag = /* @__PURE__ */ ((AdapterTag2) => {
   return AdapterTag2;
 })(AdapterTag || {});
 
-export { AdapterTag, Chain, evm_exports as EVM, solana_exports as Solana, ton_exports as TON, WalletType, allChains, allEvmChains, getTimestamp, isAddress, normalizeAddress, retry, sleep, stringify, toResult };
+export { AdapterTag, Chain, evm_exports as EVM, MessagesReleaser, solana_exports as Solana, ton_exports as TON, TryStepsExecutor, WalletType, WorkflowAction, WorkflowBreakError, WorkflowContext, WorkflowResult, WorkflowRetry, allChains, allEvmChains, getTimestamp, isAddress, normalizeAddress, retry, sleep, stringify, toResult };

package/dist/utils/index.d.ts

@@ -4,3 +4,6 @@ export * from './stringify';
 export * from './is-address';
 export * from './get-timestamp';
 export * from './normalize-address';
+export * from './messages-releaser';
+export * from './try-steps-executor';
+export * from './workflow-retry';

package/dist/utils/messages-releaser.d.ts

@@ -0,0 +1,13 @@
+export type MessagesReleaserOptions = {
+    separator?: string;
+};
+export declare class MessagesReleaser {
+    private _messages;
+    private _separator;
+    constructor(opts?: MessagesReleaserOptions);
+    get separator(): string;
+    get messages(): string[];
+    release(lastMessage?: string): string;
+    add(...msgs: string[]): void;
+    private reset;
+}

package/dist/utils/messages-releaser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/try-steps-executor.d.ts

@@ -0,0 +1,15 @@
+import { MessagesReleaser } from './messages-releaser';
+export type ExecuteFn<T> = () => Promise<T>;
+export type OnSuccessFn = () => Promise<void>;
+export type OnFailureFn = (message: string) => Promise<void>;
+export type StepOpts<R> = {
+    executeFn: ExecuteFn<R>;
+    onSuccessMessage: string;
+    onFailureFn: OnFailureFn;
+};
+export declare class TryStepsExecutor {
+    private msgsReleaser;
+    private onFailureFn;
+    constructor(initialReleaser: MessagesReleaser, initialOnFailureFn: OnFailureFn);
+    executeStep<ER, FR>(executeFn: ExecuteFn<ER>, onSuccessMessage: string, onFailureMessage: string): Promise<ER | FR>;
+}