@0xsequence/account 2.3.18 → 2.3.20

package/dist/declarations/src/account.d.ts

@@ -0,0 +1,178 @@
+import { commons } from '@0xsequence/core';
+import { migrator } from '@0xsequence/migration';
+import { ChainId, NetworkConfig } from '@0xsequence/network';
+import { type FeeOption, type FeeQuote, type Relayer } from '@0xsequence/relayer';
+import type { tracker } from '@0xsequence/sessions';
+import type { SignatureOrchestrator } from '@0xsequence/signhub';
+import { Wallet } from '@0xsequence/wallet';
+import { ethers } from 'ethers';
+import { AccountSigner, AccountSignerOptions } from "./signer.js";
+export type AccountStatus = {
+    original: {
+        version: number;
+        imageHash: string;
+        context: commons.context.WalletContext;
+    };
+    onChain: {
+        imageHash: string;
+        config: commons.config.Config;
+        version: number;
+        deployed: boolean;
+    };
+    fullyMigrated: boolean;
+    signedMigrations: migrator.SignedMigration[];
+    version: number;
+    presignedConfigurations: tracker.PresignedConfigLink[];
+    imageHash: string;
+    config: commons.config.Config;
+    checkpoint: ethers.BigNumberish;
+    canOnchainValidate: boolean;
+};
+export type AccountOptions = {
+    address: string;
+    tracker: tracker.ConfigTracker & migrator.PresignedMigrationTracker;
+    contexts: commons.context.VersionedContext;
+    migrations?: migrator.Migrations;
+    orchestrator: SignatureOrchestrator;
+    networks: NetworkConfig[];
+    jwt?: string;
+    projectAccessKey?: string;
+};
+export interface PreparedTransactions {
+    transactions: commons.transaction.SimulatedTransaction[];
+    flatDecorated: commons.transaction.Transaction[];
+    feeOptions: FeeOption[];
+    feeQuote?: FeeQuote;
+}
+export declare class Account {
+    readonly address: string;
+    readonly networks: NetworkConfig[];
+    readonly tracker: tracker.ConfigTracker & migrator.PresignedMigrationTracker;
+    readonly contexts: commons.context.VersionedContext;
+    readonly migrator: migrator.Migrator;
+    readonly migrations: migrator.Migrations;
+    private orchestrator;
+    private jwt?;
+    private projectAccessKey?;
+    constructor(options: AccountOptions);
+    getSigner(chainId: ChainId, options?: AccountSignerOptions): AccountSigner;
+    static new(options: {
+        config: commons.config.SimpleConfig;
+        tracker: tracker.ConfigTracker & migrator.PresignedMigrationTracker;
+        contexts: commons.context.VersionedContext;
+        orchestrator: SignatureOrchestrator;
+        networks: NetworkConfig[];
+        migrations?: migrator.Migrations;
+        projectAccessKey?: string;
+    }): Promise<Account>;
+    getAddress(): Promise<string>;
+    get version(): number;
+    get coders(): {
+        signature: commons.signature.SignatureCoder;
+        config: commons.config.ConfigCoder;
+    };
+    network(chainId: ethers.BigNumberish): NetworkConfig;
+    providerFor(chainId: ethers.BigNumberish): ethers.Provider;
+    reader(chainId: ethers.BigNumberish): commons.reader.Reader;
+    relayer(chainId: ethers.BigNumberish): Relayer;
+    setOrchestrator(orchestrator: SignatureOrchestrator): void;
+    setJwt(jwt: string): void;
+    contextFor(version: number): commons.context.WalletContext;
+    walletForStatus(chainId: ethers.BigNumberish, status: Pick<AccountStatus, 'version'> & Pick<AccountStatus, 'config'>): Wallet;
+    walletFor(chainId: ethers.BigNumberish, context: commons.context.WalletContext, config: commons.config.Config, coders: typeof this.coders): Wallet;
+    status(chainId: ethers.BigNumberish, longestPath?: boolean): Promise<AccountStatus>;
+    private mustBeFullyMigrated;
+    predecorateSignedTransactions(status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.SignedTransactionBundle[]>;
+    predecorateTransactions(txs: commons.transaction.Transactionish, status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.Transactionish>;
+    decorateTransactions(bundles: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[], status: AccountStatus, chainId?: ethers.BigNumberish): Promise<commons.transaction.IntendedTransactionBundle>;
+    decorateSignature<T extends ethers.BytesLike>(signature: T, status: Partial<Pick<AccountStatus, 'presignedConfigurations'>>): Promise<T | string>;
+    publishWitnessFor(signers: string[], chainId?: ethers.BigNumberish): Promise<void>;
+    publishWitness(): Promise<void>;
+    signDigest(digest: ethers.BytesLike, chainId: ethers.BigNumberish, decorate?: boolean, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw', metadata?: object): Promise<string>;
+    buildOnChainSignature(digest: ethers.BytesLike): {
+        bundle: commons.transaction.TransactionBundle;
+        signature: string;
+    };
+    private buildEIP6492Signature;
+    editConfig(changes: {
+        add?: commons.config.SimpleSigner[];
+        remove?: string[];
+        threshold?: ethers.BigNumberish;
+    }): Promise<void>;
+    updateConfig(config: commons.config.Config): Promise<void>;
+    /**
+     *  This method is used to bootstrap the wallet on a given chain.
+     *  this deploys the wallets and executes all the necessary transactions
+     *  for that wallet to start working with the given version.
+     *
+     *  This usually involves: (a) deploying the wallet, (b) executing migrations
+     *
+     *  Notice: It should NOT explicitly include chained signatures. Unless internally used
+     *  by any of the migrations.
+     *
+     */
+    buildBootstrapTransactions(status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.IntendedTransactionBundle>;
+    bootstrapTransactions(chainId: ethers.BigNumberish, prestatus?: AccountStatus): Promise<Omit<commons.transaction.IntendedTransactionBundle, 'chainId'>>;
+    doBootstrap(chainId: ethers.BigNumberish, feeQuote?: FeeQuote, prestatus?: AccountStatus): Promise<commons.transaction.TransactionResponse<any>>;
+    /**
+     * Signs a message.
+     *
+     * This method will sign the message using the account associated with this signer
+     * and the specified chain ID. If the message is already prefixed with the EIP-191
+     * prefix, it will be hashed directly. Otherwise, it will be prefixed before hashing.
+     *
+     * @param message - The message to sign. Can be a string or BytesLike.
+     * @param chainId - The chain ID to use for signing
+     * @param cantValidateBehavior - Behavior when the wallet cannot validate on-chain
+     * @returns A Promise that resolves to the signature as a hexadecimal string
+     */
+    signMessage(message: ethers.BytesLike, chainId: ethers.BigNumberish, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'): Promise<string>;
+    signTransactions(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, pstatus?: AccountStatus, options?: {
+        nonceSpace?: ethers.BigNumberish;
+        serial?: boolean;
+    }): Promise<commons.transaction.SignedTransactionBundle>;
+    signMigrations(chainId: ethers.BigNumberish, editConfig: (prevConfig: commons.config.Config) => commons.config.Config): Promise<boolean>;
+    signAllMigrations(editConfig: (prevConfig: commons.config.Config) => commons.config.Config): Promise<{
+        signedMigrations: Array<any>;
+        failedChains: number[];
+    }>;
+    isMigratedAllChains(): Promise<{
+        migratedAllChains: boolean;
+        failedChains: number[];
+    }>;
+    sendSignedTransactions(signedBundle: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[], chainId: ethers.BigNumberish, quote?: FeeQuote, pstatus?: AccountStatus, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void, projectAccessKey?: string): Promise<ethers.TransactionResponse>;
+    fillGasLimits(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, status?: AccountStatus): Promise<commons.transaction.SimulatedTransaction[]>;
+    gasRefundQuotes(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, stubSignatureOverrides: Map<string, string>, status?: AccountStatus, options?: {
+        simulate?: boolean;
+        projectAccessKey?: string;
+    }): Promise<{
+        options: FeeOption[];
+        quote?: FeeQuote;
+        decorated: commons.transaction.IntendedTransactionBundle;
+    }>;
+    prepareTransactions(args: {
+        txs: commons.transaction.Transactionish;
+        chainId: ethers.BigNumberish;
+        stubSignatureOverrides: Map<string, string>;
+        simulateForFeeOptions?: boolean;
+        projectAccessKey?: string;
+    }): Promise<PreparedTransactions>;
+    sendTransaction(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, quote?: FeeQuote, skipPreDecorate?: boolean, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void, options?: {
+        nonceSpace?: ethers.BigNumberish;
+        serial?: boolean;
+        projectAccessKey?: string;
+    }): Promise<ethers.TransactionResponse | undefined>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, message: Record<string, any>, chainId: ethers.BigNumberish, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'): Promise<string>;
+    getSigners(): Promise<Array<{
+        address: string;
+        network: ChainId;
+        weight: number;
+    }>>;
+    getAllSigners(): Promise<{
+        address: string;
+        weight: number;
+        network: number;
+        flaggedForRemoval: boolean;
+    }[]>;
+}
+export declare function isAccount(value: any): value is Account;

package/dist/declarations/src/index.d.ts

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

package/dist/declarations/src/signer.d.ts

@@ -0,0 +1,58 @@
+import { ChainId } from '@0xsequence/network';
+import { Account } from "./account.js";
+import { ethers } from 'ethers';
+import { commons } from '@0xsequence/core';
+import { FeeOption } from '@0xsequence/relayer';
+export type AccountSignerOptions = {
+    nonceSpace?: ethers.BigNumberish;
+    cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw';
+    stubSignatureOverrides?: Map<string, string>;
+    selectFee?: (txs: ethers.TransactionRequest | commons.transaction.Transactionish, options: FeeOption[]) => Promise<FeeOption | undefined>;
+};
+export declare class AccountSigner implements ethers.AbstractSigner<ethers.Provider> {
+    account: Account;
+    chainId: ChainId;
+    readonly options?: AccountSignerOptions | undefined;
+    constructor(account: Account, chainId: ChainId, options?: AccountSignerOptions | undefined);
+    get provider(): ethers.Provider;
+    getAddress(): Promise<string>;
+    /**
+     * Signs a message.
+     *
+     * This method will sign the message using the account associated with this signer
+     * and the specified chain ID. The message is already being prefixed with the EIP-191 prefix.
+     *
+     * @param message - The message to sign. Can be a string or BytesLike.
+     * @returns A Promise that resolves to the signature as a hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const signer = account.getSigner(chainId)
+     *
+     * const message = "Hello, Sequence!";
+     * const signature = await signer.signMessage(message);
+     * console.log(signature);
+     * // => "0x123abc..." (hexadecimal signature)
+     */
+    signMessage(message: string | ethers.BytesLike): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, value: Record<string, any>): Promise<string>;
+    private defaultSelectFee;
+    sendTransaction(txs: commons.transaction.Transactionish, options?: {
+        simulateForFeeOptions?: boolean;
+    }): Promise<ethers.TransactionResponse>;
+    getBalance(blockTag?: ethers.BlockTag | undefined): Promise<bigint>;
+    call(transaction: ethers.TransactionRequest, blockTag?: ethers.BlockTag): Promise<string>;
+    resolveName(name: string): Promise<string>;
+    connect(_provider: ethers.Provider): ethers.Signer;
+    signTransaction(transaction: ethers.TransactionRequest): Promise<string>;
+    getTransactionCount(blockTag?: ethers.BlockTag | undefined): Promise<number>;
+    estimateGas(transaction: ethers.TransactionRequest): Promise<bigint>;
+    getChainId(): Promise<number>;
+    getGasPrice(): Promise<bigint>;
+    getFeeData(): Promise<ethers.FeeData>;
+    getNonce(blockTag?: ethers.BlockTag): Promise<number>;
+    populateCall(tx: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>>;
+    checkTransaction(transaction: ethers.TransactionRequest): ethers.TransactionRequest;
+    populateTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>>;
+    _checkProvider(operation?: string | undefined): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/account",
-  "version": "2.3.18",
+  "version": "2.3.20",
   "description": "tools for migrating sequence wallets to new versions",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/account",
   "source": "src/index.ts",
@@ -12,21 +12,21 @@
     "ethers": ">=6"
   },
   "dependencies": {
-    "@0xsequence/abi": "2.3.18",
-    "@0xsequence/core": "2.3.18",
-    "@0xsequence/migration": "2.3.18",
-    "@0xsequence/network": "2.3.18",
-    "@0xsequence/relayer": "2.3.18",
-    "@0xsequence/sessions": "2.3.18",
-    "@0xsequence/utils": "2.3.18",
-    "@0xsequence/wallet": "2.3.18"
+    "@0xsequence/abi": "2.3.20",
+    "@0xsequence/core": "2.3.20",
+    "@0xsequence/migration": "2.3.20",
+    "@0xsequence/network": "2.3.20",
+    "@0xsequence/relayer": "2.3.20",
+    "@0xsequence/sessions": "2.3.20",
+    "@0xsequence/utils": "2.3.20",
+    "@0xsequence/wallet": "2.3.20"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "ethers": "6.13.4",
     "nyc": "^15.1.0",
-    "@0xsequence/signhub": "2.3.18",
-    "@0xsequence/tests": "2.3.18"
+    "@0xsequence/signhub": "2.3.20",
+    "@0xsequence/tests": "2.3.20"
   },
   "files": [
     "src",