0xtrails 0.0.1 → 0.0.2

package/dist/sequenceWallet.js

@@ -0,0 +1,374 @@
+import { Account } from "@0xsequence/account";
+import { commons } from "@0xsequence/core";
+import { allNetworks } from "@0xsequence/network";
+import { trackers } from "@0xsequence/sessions";
+import { Orchestrator } from "@0xsequence/signhub";
+import { ethers } from "ethers";
+import { Abi, AbiFunction } from "ox";
+import { bytesToHex, hexToBytes, toHex, } from "viem";
+import { getRelayerUrl } from "./relayer.js";
+export const TRACKER = new trackers.remote.RemoteConfigTracker("https://sessions.sequence.app");
+export function getAccountNetworks(input) {
+    return allNetworks.map((network) => {
+        try {
+            const relayerUrl = getRelayerUrl(input.relayerConfig, network.chainId);
+            if (relayerUrl) {
+                const relayer = {
+                    provider: new ethers.JsonRpcProvider(network.rpcUrl),
+                    url: relayerUrl,
+                    projectAccessKey: input.sequenceProjectAccessKey,
+                };
+                return {
+                    ...network,
+                    relayer,
+                };
+            }
+        }
+        catch (_err) {
+            // noop
+        }
+        return network;
+    });
+}
+export async function createSequenceWallet(threshold, signers, relayerConfig, sequenceProjectAccessKey) {
+    const account = await Account.new({
+        config: {
+            threshold,
+            // By default a random checkpoint is generated every second
+            checkpoint: Math.floor(Date.now() / 1000),
+            signers: signers,
+        },
+        tracker: TRACKER,
+        contexts: commons.context.defaultContexts,
+        orchestrator: new Orchestrator([]),
+        networks: getAccountNetworks({ relayerConfig, sequenceProjectAccessKey }),
+    });
+    // Try to fetch the config from the tracker
+    const reverse1 = await TRACKER.imageHashOfCounterfactualWallet({
+        wallet: account.address,
+    });
+    if (!reverse1) {
+        throw new Error("Failed to fetch imageHash from the tracker");
+    }
+    // Try to fetch the imageHash from the tracker
+    const reverse2 = await TRACKER.configOfImageHash({
+        imageHash: reverse1.imageHash,
+    });
+    if (!reverse2) {
+        throw new Error("Failed to fetch config from the tracker");
+    }
+    return account;
+}
+export function toSequenceTransactions(txs) {
+    return txs.map(toSequenceTransaction);
+}
+export function toSequenceTransaction(tx) {
+    return {
+        to: tx.to,
+        value: tx.value ? BigInt(tx.value) : undefined,
+        data: tx.data,
+        gasLimit: tx.gasLimit ? BigInt(tx.gasLimit) : undefined,
+        delegateCall: tx.delegateCall || false,
+        revertOnError: tx.revertOnError || false,
+    };
+}
+export function accountFor(args) {
+    const signers = [];
+    if (args.signatures) {
+        for (const { signer, signature } of args.signatures) {
+            // Some ECDSA libraries may return the signature with `v` as 0x00 or 0x01
+            // but the Sequence protocol expects it to be 0x1b or 0x1c. We need to
+            // adjust the signature to match the protocol.
+            const signatureArr = hexToBytes(signature);
+            if (signatureArr.length === 66 &&
+                (signatureArr[64] === 0 || signatureArr[64] === 1)) {
+                signatureArr[64] = signatureArr[64] + 27;
+            }
+            signers.push(new StaticSigner(signer, bytesToHex(signatureArr)));
+        }
+    }
+    console.log("[trails-sdk] signers", signers);
+    return new Account({
+        address: args.address,
+        tracker: TRACKER,
+        contexts: commons.context.defaultContexts,
+        orchestrator: new Orchestrator(signers),
+        networks: getAccountNetworks({
+            relayerConfig: args.relayerConfig,
+            sequenceProjectAccessKey: args.sequenceProjectAccessKey,
+        }),
+    });
+}
+export function digestOf(tx) {
+    return commons.transaction.digestOfTransactions(commons.transaction.encodeNonce(tx.space, tx.nonce), toSequenceTransactions(tx.transactions));
+}
+export function subdigestOf(tx) {
+    const digest = digestOf(tx);
+    return commons.signature.subdigestOf({
+        digest,
+        chainId: tx.chainId,
+        address: tx.wallet,
+    });
+}
+export function fromSequenceTransactions(wallet, txs) {
+    const sequenceTxs = commons.transaction.fromTransactionish(wallet, txs);
+    return sequenceTxs.map((stx) => ({
+        to: stx.to,
+        value: stx.value?.toString(),
+        data: stx.data?.toString(),
+        gasLimit: stx.gasLimit?.toString(),
+        delegateCall: stx.delegateCall,
+        revertOnError: stx.revertOnError,
+    }));
+}
+export function recoverSigner(signatures, subdigest) {
+    const res = [];
+    for (const signature of signatures) {
+        try {
+            const r = commons.signer.recoverSigner(subdigest, signature);
+            res.push({ signer: r, signature: signature });
+        }
+        catch (e) {
+            console.error("[trails-sdk] Failed to recover signature", e);
+        }
+    }
+    return res;
+}
+export async function simpleCreateSequenceWallet(account, relayerConfig, sequenceProjectAccessKey) {
+    const signer = account.address;
+    const threshold = 1;
+    const weight = 1;
+    const wallet = await createSequenceWallet(threshold, [{ address: signer, weight: weight }], relayerConfig, sequenceProjectAccessKey);
+    return wallet.address;
+}
+export async function getIsWalletDeployed(wallet, publicClient) {
+    const hasCode = await publicClient?.getCode({
+        address: wallet,
+    });
+    const isDeployed = hasCode !== undefined && hasCode !== "0x";
+    return isDeployed;
+}
+export async function waitForWalletDeployment(wallet, publicClient) {
+    while (true) {
+        const isDeployed = await getIsWalletDeployed(wallet, publicClient);
+        if (isDeployed) {
+            break;
+        }
+        console.log("[trails-sdk] waiting for wallet deployment");
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+}
+export async function sequenceSendTransaction(sequenceWalletAddress, accountClient, publicClient, calls, chain, relayerConfig, sequenceProjectAccessKey) {
+    const chainId = chain.id;
+    if (!accountClient?.account?.address || !sequenceWalletAddress) {
+        throw new Error("Privy signer or sequence wallet address not available");
+    }
+    const txsToExecute = calls.map((call) => {
+        return {
+            to: call.to,
+            data: call.data,
+            value: call.value || "0",
+            revertOnError: true,
+        };
+    });
+    const txe = {
+        wallet: sequenceWalletAddress,
+        space: Math.floor(Date.now()).toString(),
+        nonce: "0",
+        chainId: chainId.toString(),
+        transactions: txsToExecute,
+    };
+    // Calculate the tx subdigest
+    const subdigest = subdigestOf(txe);
+    const digestBytes = hexToBytes(subdigest);
+    // Sign the tx subdigest
+    const signature = await accountClient.signMessage({
+        account: accountClient.account,
+        message: { raw: digestBytes },
+    });
+    const suffixed = `${signature}02`;
+    // Get the account for the Sequence Wallet with signatures
+    const sequenceAccount = accountFor({
+        address: sequenceWalletAddress,
+        signatures: [
+            {
+                signer: accountClient.account?.address,
+                signature: suffixed,
+            },
+        ],
+        relayerConfig,
+        sequenceProjectAccessKey,
+    });
+    const sequenceTxs = toSequenceTransactions(txsToExecute);
+    const status = await sequenceAccount.status(chainId);
+    const wallet = sequenceAccount.walletForStatus(chainId, status);
+    console.log("[trails-sdk] sequence wallet", wallet);
+    const isDeployed = await getIsWalletDeployed(wallet.address, publicClient);
+    if (!isDeployed) {
+        console.log("[trails-sdk] deploying sequence wallet");
+        const deployTx = await wallet.buildDeployTransaction();
+        if (!wallet.relayer)
+            throw new Error("Wallet deploy requires a relayer");
+        console.log("[trails-sdk] deploy Tx", deployTx);
+        console.log("[trails-sdk] deployTx entrypoint:", deployTx.entrypoint);
+        console.log("[trails-sdk] deployTx transactions:", deployTx.transactions);
+        console.log("[trails-sdk] getting fee options 0");
+        const feeOptions = await wallet.relayer.getFeeOptions(wallet.address, ...deployTx.transactions);
+        const quote = feeOptions?.quote;
+        console.log("[trails-sdk] feeOptions", feeOptions);
+        // Check if deployment is whitelisted (no fees required)
+        if (feeOptions?.options.length === 0) {
+            console.log("[trails-sdk] Deployment is whitelisted - no fees required");
+            const bytes = new Uint8Array(32);
+            crypto.getRandomValues(bytes);
+            wallet.relayer.relay({
+                entrypoint: deployTx.entrypoint,
+                transactions: deployTx.transactions,
+                chainId: wallet.chainId,
+                intent: {
+                    id: toHex(bytes),
+                    wallet: wallet.address,
+                },
+            }, quote);
+            console.log("[trails-sdk] Deployment relayed");
+            await waitForWalletDeployment(wallet.address, publicClient);
+            console.log("[trails-sdk] sequence wallet deployed");
+        }
+        else {
+            const option = feeOptions?.options[0];
+            if (!option) {
+                throw new Error("fee option not found");
+            }
+            console.log("[trails-sdk] option", option);
+            if (option) {
+                console.log("[trails-sdk] Using native token for deployment fee");
+                // Use encodeGasRefundTransaction to create the fee transaction
+                const feeTransactions = encodeGasRefundTransaction(option);
+                console.log("[trails-sdk] Fee transactions:", feeTransactions);
+                // Include both deployment and fee transactions
+                const allTransactions = [...deployTx.transactions];
+                console.log("[trails-sdk] All transactions (deployment + fees):", allTransactions);
+                const predecorated = await sequenceAccount.predecorateTransactions(allTransactions, status, chainId);
+                const signed = await sequenceAccount.signTransactions(predecorated, chainId);
+                console.log("[trails-sdk] signed transactions with fees:", signed.transactions);
+                console.log("[trails-sdk] signed entrypoint with fees:", signed.entrypoint);
+                const bytes = new Uint8Array(32);
+                crypto.getRandomValues(bytes);
+                wallet.relayer.relay({
+                    entrypoint: deployTx.entrypoint,
+                    transactions: deployTx.transactions,
+                    chainId: wallet.chainId,
+                    intent: {
+                        id: toHex(bytes),
+                        wallet: wallet.address,
+                    },
+                }, quote);
+                console.log("[trails-sdk] relayed deployment");
+                await waitForWalletDeployment(wallet.address, publicClient);
+                console.log("[trails-sdk] sequence wallet deployed");
+            }
+            else {
+                throw new Error("ERC20 fee payment for deployment is not supported yet. Please use native token or a relayer with free wallet deployments.");
+            }
+        }
+    }
+    console.log("[trails-sdk] getting fee options 1");
+    const feeOptions = await wallet.relayer.getFeeOptions(wallet.address, ...sequenceTxs);
+    // Find the USDC option for fee payment
+    const option = feeOptions?.options.find((option) => option.token.symbol === "USDC");
+    const quote = feeOptions?.quote;
+    // Use encodeGasRefundTransaction to create the fee transaction
+    const feeTransactions = encodeGasRefundTransaction(option);
+    console.log("[trails-sdk] Fee transactions:", feeTransactions);
+    // Sign the txs with the Sequence Wallet
+    const signed = await wallet.signTransactions([...feeTransactions, ...sequenceTxs], commons.transaction.encodeNonce(txe.space, txe.nonce));
+    // Relay the txs to sponsor them
+    const relayer = sequenceAccount.relayer(chainId);
+    const relayed = await relayer.relay(signed, quote);
+    return relayed?.hash || null;
+}
+export class StaticSigner {
+    address;
+    signature;
+    signatureBytes;
+    savedSuffix;
+    constructor(address, signature) {
+        this.address = address;
+        this.signature = signature;
+        const raw = hexToBytes(this.signature);
+        // Separate last byte as suffix
+        this.savedSuffix = raw.slice(-1);
+        this.signatureBytes = raw.slice(0, -1);
+    }
+    async buildDeployTransaction() {
+        return undefined;
+    }
+    async predecorateSignedTransactions() {
+        return [];
+    }
+    async decorateTransactions(og) {
+        return og;
+    }
+    async sign() {
+        return this.signatureBytes;
+    }
+    notifyStatusChange() { }
+    suffix() {
+        return this.savedSuffix;
+    }
+    async getAddress() {
+        return this.address;
+    }
+}
+export async function getFeeOptions(relayer, wallet, chainId, calls) {
+    const feeOptions = await relayer.feeOptions(wallet, BigInt(chainId), calls);
+    return feeOptions;
+}
+// Import the encodeGasRefundTransaction function
+function encodeGasRefundTransaction(option) {
+    if (!option)
+        return [];
+    const value = BigInt(option.value);
+    switch (option.token.type) {
+        case "UNKNOWN":
+            return [
+                {
+                    delegateCall: false,
+                    revertOnError: true,
+                    gasLimit: option.gasLimit,
+                    to: option.to,
+                    value: value.toString(),
+                    data: "0x",
+                },
+            ];
+        case "ERC20_TOKEN": {
+            if (!option.token.contractAddress) {
+                throw new Error(`No contract address for ERC-20 fee option`);
+            }
+            const [transfer] = Abi.from([
+                {
+                    inputs: [{ type: "address" }, { type: "uint256" }],
+                    name: "transfer",
+                    outputs: [{ type: "bool" }],
+                    stateMutability: "nonpayable",
+                    type: "function",
+                },
+            ]);
+            return [
+                {
+                    delegateCall: false,
+                    revertOnError: true,
+                    gasLimit: option.gasLimit,
+                    to: option.token.contractAddress,
+                    value: "0",
+                    data: AbiFunction.encodeData(transfer, [
+                        option.to,
+                        value,
+                    ]),
+                },
+            ];
+        }
+        default:
+            throw new Error(`Unhandled fee token type ${option.token.type}`);
+    }
+}

package/dist/theme.d.ts

@@ -0,0 +1,3 @@
+export type Theme = "light" | "dark" | "auto";
+export type ActiveTheme = "light" | "dark";
+//# sourceMappingURL=theme.d.ts.map

package/dist/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../src/theme.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,CAAA"}

package/dist/theme.js

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

package/dist/toSimpleSmartAccount.d.ts

@@ -0,0 +1,95 @@
+import { type Account, type Address, type Assign, BaseError, type Chain, type Client, type EIP1193Provider, type Hex, type JsonRpcAccount, type LocalAccount, type OneOf, type Prettify, type Transport, type WalletClient } from "viem";
+import { entryPoint07Abi, type SmartAccount, type SmartAccountImplementation } from "viem/account-abstraction";
+export declare const getAccountInitCode: (owner: Address, index?: bigint) => Promise<Hex>;
+export type ToSimpleSmartAccountParameters<owner extends OneOf<EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount>> = {
+    client: Client<Transport, Chain | undefined, JsonRpcAccount | LocalAccount | undefined>;
+    owner: owner;
+    entryPoint?: {
+        address: Address;
+        version: "0.7";
+    };
+    factoryAddress?: Address;
+    index?: bigint;
+    address?: Address;
+    nonceKey?: bigint;
+    accountLogicAddress?: Address;
+};
+export declare const getFactoryAddress: (factoryAddress?: Address) => Address;
+export type SimpleSmartAccountImplementation = Assign<SmartAccountImplementation<typeof entryPoint07Abi, "0.7", object, false>, {
+    sign: NonNullable<SmartAccountImplementation["sign"]>;
+}>;
+export type ToSimpleSmartAccountReturnType = SmartAccount<SimpleSmartAccountImplementation>;
+/**
+ * @description Creates an Simple Account from a private key.
+ *
+ * @returns A Private Key Simple Account.
+ */
+export declare function toSimpleSmartAccount<owner extends OneOf<EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount>>(parameters: ToSimpleSmartAccountParameters<owner>): Promise<ToSimpleSmartAccountReturnType>;
+export declare const executeSingleAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "dest";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "func";
+        readonly type: "bytes";
+    }];
+    readonly name: "execute";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+export type GetAccountNonceParams = {
+    address: Address;
+    entryPointAddress: Address;
+    key?: bigint;
+};
+/**
+ * Returns the nonce of the account with the entry point.
+ */
+export declare const getAccountNonce: (client: Client, args: GetAccountNonceParams) => Promise<bigint>;
+export declare const GetSenderAddressHelperByteCode = "0x60806040526102a28038038091610015826100ae565b6080396040816080019112610093576080516001600160a01b03811681036100935760a0516001600160401b0381116100935782609f82011215610093578060800151610061816100fc565b9361006f60405195866100d9565b81855260a082840101116100935761008e9160a0602086019101610117565b610196565b600080fd5b634e487b7160e01b600052604160045260246000fd5b6080601f91909101601f19168101906001600160401b038211908210176100d457604052565b610098565b601f909101601f19168101906001600160401b038211908210176100d457604052565b6001600160401b0381116100d457601f01601f191660200190565b60005b83811061012a5750506000910152565b818101518382015260200161011a565b6040916020825261015a8151809281602086015260208686019101610117565b601f01601f1916010190565b3d15610191573d90610177826100fc565b9161018560405193846100d9565b82523d6000602084013e565b606090565b600091908291826040516101cd816101bf6020820195639b249f6960e01b87526024830161013a565b03601f1981018352826100d9565b51925af16101d9610166565b906102485760048151116000146101f7576024015160005260206000f35b60405162461bcd60e51b8152602060048201526024808201527f67657453656e64657241646472657373206661696c656420776974686f7574206044820152636461746160e01b6064820152608490fd5b60405162461bcd60e51b815260206004820152602b60248201527f67657453656e6465724164647265737320646964206e6f74207265766572742060448201526a185cc8195e1c1958dd195960aa1b6064820152608490fdfe";
+export declare const GetSenderAddressHelperAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+export type GetSenderAddressParams = OneOf<{
+    initCode: Hex;
+    entryPointAddress: Address;
+    factory?: never;
+    factoryData?: never;
+} | {
+    entryPointAddress: Address;
+    factory: Address;
+    factoryData: Hex;
+    initCode?: never;
+}>;
+export declare class InvalidEntryPointError extends BaseError {
+    name: string;
+    constructor({ cause, entryPointAddress, }?: {
+        cause?: BaseError;
+        entryPointAddress?: Address;
+    });
+}
+/**
+ * Returns the address of the account that will be deployed with the given init code.
+ */
+export declare const getSenderAddress: (client: Client, args: Prettify<GetSenderAddressParams>) => Promise<Address>;
+export type EthereumProvider = OneOf<{
+    request(...args: any): Promise<any>;
+} | EIP1193Provider>;
+export declare function toOwner<provider extends EthereumProvider>({ owner, address, }: {
+    owner: OneOf<provider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount>;
+    address?: Address;
+}): Promise<LocalAccount>;
+//# sourceMappingURL=toSimpleSmartAccount.d.ts.map

package/dist/toSimpleSmartAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSimpleSmartAccount.d.ts","sourceRoot":"","sources":["../src/toSimpleSmartAccount.ts"],"names":[],"mappings":"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"}