@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.45

package/dist/src/accounts/signing/passkeys.js

@@ -1,119 +0,0 @@
-import { bytesToHex, encodeAbiParameters, hexToBytes, keccak256, } from 'viem';
-function parsePublicKey(publicKey) {
-    const bytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;
-    const offset = bytes.length === 65 ? 1 : 0;
-    const x = bytes.slice(offset, 32 + offset);
-    const y = bytes.slice(32 + offset, 64 + offset);
-    return {
-        x: BigInt(bytesToHex(x)),
-        y: BigInt(bytesToHex(y)),
-    };
-}
-function parseSignature(signature) {
-    const bytes = typeof signature === 'string' ? hexToBytes(signature) : signature;
-    const r = bytes.slice(0, 32);
-    const s = bytes.slice(32, 64);
-    return {
-        r: BigInt(bytesToHex(r)),
-        s: BigInt(bytesToHex(s)),
-    };
-}
-function generateCredentialId(pubKeyX, pubKeyY, account) {
-    return keccak256(encodeAbiParameters([
-        {
-            type: 'uint256',
-        },
-        {
-            type: 'uint256',
-        },
-        {
-            type: 'address',
-        },
-    ], [pubKeyX, pubKeyY, account]));
-}
-function packSignature(credIds, usePrecompile, webAuthns) {
-    // Sort both `credIds` and `webAuthns` by credIds
-    const credIdsAndWebAuthns = credIds.map((credId, index) => ({
-        credId,
-        webAuthn: webAuthns[index],
-    }));
-    credIdsAndWebAuthns.sort((a, b) => a.credId.localeCompare(b.credId));
-    credIds = credIdsAndWebAuthns.map(({ credId }) => credId);
-    webAuthns = credIdsAndWebAuthns.map(({ webAuthn }) => webAuthn);
-    // Encode
-    return encodeAbiParameters([
-        {
-            type: 'bytes32[]',
-            name: 'credIds',
-        },
-        {
-            type: 'bool',
-            name: 'usePrecompile',
-        },
-        {
-            type: 'tuple[]',
-            name: 'webAuthns',
-            components: [
-                {
-                    type: 'bytes',
-                    name: 'authenticatorData',
-                },
-                {
-                    type: 'string',
-                    name: 'clientDataJSON',
-                },
-                {
-                    type: 'uint256',
-                    name: 'challengeIndex',
-                },
-                {
-                    type: 'uint256',
-                    name: 'typeIndex',
-                },
-                {
-                    type: 'uint256',
-                    name: 'r',
-                },
-                {
-                    type: 'uint256',
-                    name: 's',
-                },
-            ],
-        },
-    ], [credIds, usePrecompile, webAuthns]);
-}
-function packSignatureV0(webauthn, usePrecompiled) {
-    return encodeAbiParameters([
-        { type: 'bytes', name: 'authenticatorData' },
-        {
-            type: 'string',
-            name: 'clientDataJSON',
-        },
-        {
-            type: 'uint256',
-            name: 'responseTypeLocation',
-        },
-        {
-            type: 'uint256',
-            name: 'r',
-        },
-        {
-            type: 'uint256',
-            name: 's',
-        },
-        {
-            type: 'bool',
-            name: 'usePrecompiled',
-        },
-    ], [
-        webauthn.authenticatorData,
-        webauthn.clientDataJSON,
-        typeof webauthn.typeIndex === 'bigint'
-            ? webauthn.typeIndex
-            : BigInt(webauthn.typeIndex),
-        webauthn.r,
-        webauthn.s,
-        usePrecompiled,
-    ]);
-}
-export { parsePublicKey, parseSignature, generateCredentialId, packSignature, packSignatureV0, };

package/dist/src/accounts/signing/typedData.d.ts

@@ -1,5 +0,0 @@
-import type { Address, Chain, HashTypedDataParameters, Hex, TypedData } from 'viem';
-import type { SignerSet } from '../../types.js';
-declare function sign<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(signers: SignerSet, chain: Chain, address: Address, parameters: HashTypedDataParameters<typedData, primaryType>): Promise<Hex>;
-export { sign };
-//# sourceMappingURL=typedData.d.ts.map

package/dist/src/accounts/signing/typedData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typedData.d.ts","sourceRoot":"","sources":["../../../../accounts/signing/typedData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,OAAO,EACP,KAAK,EACL,uBAAuB,EACvB,GAAG,EACH,SAAS,EACV,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAI5C,iBAAe,IAAI,CACjB,SAAS,SAAS,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACjE,WAAW,SAAS,MAAM,SAAS,GAAG,cAAc,GAAG,MAAM,SAAS,EAEtE,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,uBAAuB,CAAC,SAAS,EAAE,WAAW,CAAC,GAC1D,OAAO,CAAC,GAAG,CAAC,CAwBd;AA6BD,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/src/accounts/signing/typedData.js

@@ -1,30 +0,0 @@
-import { SigningNotSupportedForAccountError } from '../error.js';
-import { signWithOwners } from './common.js';
-async function sign(signers, chain, address, parameters) {
-    const signingFunctions = {
-        signEcdsa: (account, params) => signEcdsa(account, params),
-        signPasskey: (account, params) => signPasskey(account, params),
-    };
-    switch (signers.type) {
-        case 'owner': {
-            return signWithOwners(signers, chain, address, parameters, signingFunctions, false, sign);
-        }
-        case 'experimental_session': {
-            throw new Error('Not supported');
-        }
-    }
-}
-async function signEcdsa(account, parameters) {
-    if (!account.signTypedData) {
-        throw new SigningNotSupportedForAccountError();
-    }
-    return await account.signTypedData(parameters);
-}
-async function signPasskey(account, parameters) {
-    const { webauthn, signature } = await account.signTypedData(parameters);
-    return {
-        webauthn,
-        signature,
-    };
-}
-export { sign };

package/dist/src/accounts/startale.d.ts

@@ -1,25 +0,0 @@
-import type { Address, Chain, Hex, PublicClient } from 'viem';
-import type { Module } from '../modules/common.js';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types.js';
-import type { ValidatorConfig } from './utils.js';
-declare const K1_DEFAULT_VALIDATOR_ADDRESS: Address;
-declare function getDeployArgs(config: RhinestoneAccountConfig): {
-    factory: `0x${string}`;
-    factoryData: `0x${string}`;
-    salt: `0x${string}`;
-    implementation: `0x${string}`;
-    initializationCallData: `0x${string}`;
-} | null;
-declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
-declare function getEip712Domain(config: RhinestoneAccountConfig, chain: Chain): {
-    name: string;
-    version: string;
-    chainId: number;
-    verifyingContract: `0x${string}`;
-    salt: "0x0000000000000000000000000000000000000000000000000000000000000000";
-};
-declare function getInstallData(module: Module): `0x${string}`;
-declare function packSignature(signature: Hex, validator: ValidatorConfig, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
-declare function getSmartAccount(client: PublicClient, address: Address, owners: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<import("viem/_types/account-abstraction").SmartAccount<import("viem/_types/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
-export { K1_DEFAULT_VALIDATOR_ADDRESS, getEip712Domain, getInstallData, getAddress, packSignature, getDeployArgs, getSmartAccount, };
-//# sourceMappingURL=startale.d.ts.map

package/dist/src/accounts/startale.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startale.d.ts","sourceRoot":"","sources":["../../../accounts/startale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAc7D,OAAO,KAAK,EAAe,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE5D,OAAO,KAAK,EAEV,QAAQ,EACR,uBAAuB,EAExB,MAAM,UAAU,CAAA;AAOjB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,QAAA,MAAM,4BAA4B,EAAE,OACU,CAAA;AAW9C,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;SAwErD;AAoFD,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAmClD;AAED,iBAAS,eAAe,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,KAAK;;;;;;EAWrE;AAED,iBAAS,cAAc,CAAC,MAAM,EAAE,MAAM,iBAErC;AAED,iBAAe,aAAa,CAC1B,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,eAAe,EAC1B,kBAAkB,GAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAA8B,0BAQvE;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,QAAQ,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,oKAUlC;AAED,OAAO,EACL,4BAA4B,EAC5B,eAAe,EACf,cAAc,EACd,UAAU,EACV,aAAa,EACb,aAAa,EACb,eAAe,GAChB,CAAA"}

package/dist/src/accounts/startale.js

@@ -1,188 +0,0 @@
-import { concat, decodeFunctionData, encodeAbiParameters, encodeFunctionData, encodePacked, keccak256, parseAbi, slice, zeroAddress, zeroHash, } from 'viem';
-import { getSetup as getModuleSetup } from '../modules/index.js';
-import { getOwnerValidator } from '../modules/validators/core.js';
-import { AccountConfigurationNotSupportedError } from './error.js';
-import { getInstallData as getNexusInstallData, getSmartAccount as getNexusSmartAccount, packSignature as packNexusSignature, } from './nexus.js';
-const K1_DEFAULT_VALIDATOR_ADDRESS = '0x00000072f286204bb934ed49d8969e86f7dec7b1';
-const STARTALE_VERSION = '1.0.0';
-const IMPLEMENTATION_ADDRESS = '0x000000b8f5f723a680d3d7ee624fe0bc84a6e05a';
-const FACTORY_ADDRESS = '0x0000003b3e7b530b4f981ae80d9350392defef90';
-const BOOTSTRAP_ADDRESS = '0x000000552a5fae3db7a8f3917c435448f49ba6a9';
-const CREATION_CODE = '0x608060405261029d803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f754fd8b321c4649cb777ae6fdce7e89e9cceaa31a4f639795c7807eb7f1a27005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051605e908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00';
-function getDeployArgs(config) {
-    if (config.initData) {
-        if (!('factory' in config.initData)) {
-            return null;
-        }
-        const { factory, factoryData } = config.initData;
-        try {
-            const decoded = decodeFunctionData({
-                abi: parseAbi(['function createAccount(bytes,bytes32)']),
-                data: factoryData,
-            });
-            const initData = decoded.args[0];
-            const salt = decoded.args[1];
-            const initializationCallData = encodeFunctionData({
-                abi: parseAbi(['function initializeAccount(bytes)']),
-                functionName: 'initializeAccount',
-                args: [initData],
-            });
-            return {
-                factory,
-                factoryData,
-                salt,
-                implementation: IMPLEMENTATION_ADDRESS,
-                initializationCallData,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    const account = config.account;
-    const salt = account?.salt ?? zeroHash;
-    const moduleSetup = getModuleSetup(config);
-    const ownerValidator = getOwnerValidator(config);
-    const isK1 = ownerValidator.address.toLowerCase() ===
-        K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
-    if (isK1 &&
-        config.owners &&
-        'accounts' in config.owners &&
-        config.owners.accounts.length > 1) {
-        throw new AccountConfigurationNotSupportedError('K1 validator only supports a single owner', 'startale');
-    }
-    const initData = isK1
-        ? getK1InitData(config, moduleSetup)
-        : getOwnableInitData(moduleSetup);
-    const factoryData = encodeFunctionData({
-        abi: parseAbi(['function createAccount(bytes,bytes32)']),
-        functionName: 'createAccount',
-        args: [initData, salt],
-    });
-    const initializationCallData = encodeFunctionData({
-        abi: parseAbi(['function initializeAccount(bytes)']),
-        functionName: 'initializeAccount',
-        args: [initData],
-    });
-    return {
-        factory: FACTORY_ADDRESS,
-        factoryData,
-        salt,
-        implementation: IMPLEMENTATION_ADDRESS,
-        initializationCallData,
-    };
-}
-function getK1InitData(config, moduleSetup) {
-    const ownerAddress = config.owners.accounts[0]
-        .address;
-    const validators = moduleSetup.validators.filter((v) => v.address.toLowerCase() !== K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase());
-    return encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [
-        BOOTSTRAP_ADDRESS,
-        encodeFunctionData({
-            abi: parseAbi([
-                'struct BootstrapConfig {address module;bytes initData;}',
-                'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
-                'function initWithDefaultValidatorAndOtherModules(bytes calldata defaultValidatorInitData,BootstrapConfig[] calldata validators,BootstrapConfig[] calldata executors,BootstrapConfig calldata hook,BootstrapConfig[] calldata fallbacks,BootstrapPreValidationHookConfig[] calldata preValidationHooks) external payable',
-            ]),
-            functionName: 'initWithDefaultValidatorAndOtherModules',
-            args: [
-                ownerAddress,
-                validators.map((v) => ({
-                    module: v.address,
-                    initData: v.initData,
-                })),
-                moduleSetup.executors.map((e) => ({
-                    module: e.address,
-                    initData: e.initData,
-                })),
-                {
-                    module: zeroAddress,
-                    initData: zeroHash,
-                },
-                moduleSetup.fallbacks.map((f) => ({
-                    module: f.address,
-                    initData: f.initData,
-                })),
-                [],
-            ],
-        }),
-    ]);
-}
-function getOwnableInitData(moduleSetup) {
-    return encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [
-        BOOTSTRAP_ADDRESS,
-        encodeFunctionData({
-            abi: parseAbi([
-                'struct BootstrapConfig {address module;bytes initData;}',
-                'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
-                'function init(BootstrapConfig[] calldata validators,BootstrapConfig[] calldata executors,BootstrapConfig calldata hook,BootstrapConfig[] calldata fallbacks,BootstrapPreValidationHookConfig[] calldata preValidationHooks) external',
-            ]),
-            functionName: 'init',
-            args: [
-                moduleSetup.validators.map((v) => ({
-                    module: v.address,
-                    initData: v.initData,
-                })),
-                moduleSetup.executors.map((e) => ({
-                    module: e.address,
-                    initData: e.initData,
-                })),
-                {
-                    module: zeroAddress,
-                    initData: '0x',
-                },
-                moduleSetup.fallbacks.map((f) => ({
-                    module: f.address,
-                    initData: f.initData,
-                })),
-                [],
-            ],
-        }),
-    ]);
-}
-function getAddress(config) {
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        if (config.initData?.address) {
-            return config.initData.address;
-        }
-        throw new Error('Cannot derive address: deploy args not available');
-    }
-    const { factory, salt, initializationCallData } = deployArgs;
-    const accountInitData = encodeAbiParameters([
-        {
-            name: 'address',
-            type: 'address',
-        },
-        {
-            name: 'calldata',
-            type: 'bytes',
-        },
-    ], [IMPLEMENTATION_ADDRESS, initializationCallData]);
-    const hashedInitcode = keccak256(concat([CREATION_CODE, accountInitData]));
-    const hash = keccak256(encodePacked(['bytes1', 'address', 'bytes32', 'bytes'], ['0xff', factory, salt, hashedInitcode]));
-    const address = slice(hash, 12, 32);
-    return address;
-}
-function getEip712Domain(config, chain) {
-    // Works for adopted accounts too: getAddress resolves the initData cases
-    // (returns initData.address, or recomputes the CREATE2 address from
-    // initData.factory/factoryData).
-    return {
-        name: 'Startale',
-        version: STARTALE_VERSION,
-        chainId: chain.id,
-        verifyingContract: getAddress(config),
-        salt: zeroHash,
-    };
-}
-function getInstallData(module) {
-    return getNexusInstallData(module);
-}
-async function packSignature(signature, validator, transformSignature = (signature) => signature) {
-    return packNexusSignature(signature, validator, transformSignature, K1_DEFAULT_VALIDATOR_ADDRESS);
-}
-async function getSmartAccount(client, address, owners, validatorAddress, sign) {
-    return getNexusSmartAccount(client, address, owners, validatorAddress, sign, K1_DEFAULT_VALIDATOR_ADDRESS);
-}
-export { K1_DEFAULT_VALIDATOR_ADDRESS, getEip712Domain, getInstallData, getAddress, packSignature, getDeployArgs, getSmartAccount, };

package/dist/src/accounts/utils.d.ts

@@ -1,33 +0,0 @@
-import type { Address, Client, Hex } from 'viem';
-import type { RhinestoneConfig } from '../types.js';
-import { createTransport } from './json-rpc/index.js';
-type CallType = 'call' | 'delegatecall' | 'batchcall';
-interface ValidatorConfig {
-    address: Address;
-    isRoot: boolean;
-}
-interface ExecutionMode<callType extends CallType> {
-    type: callType;
-    revertOnError?: boolean;
-    selector?: Hex;
-    context?: Hex;
-}
-interface EncodeCallDataParams<callType extends CallType> {
-    mode: ExecutionMode<callType>;
-    callData: readonly {
-        to: Address;
-        value?: bigint | undefined;
-        data?: Hex | undefined;
-    }[];
-}
-interface GetAccountNonceParams {
-    address: Address;
-    entryPointAddress: Address;
-    key?: bigint;
-}
-declare function encode7579Calls<callType extends CallType>({ mode, callData, }: EncodeCallDataParams<callType>): Hex;
-declare function getAccountNonce(client: Client, args: GetAccountNonceParams): Promise<bigint>;
-declare function getBundlerClient(config: RhinestoneConfig, client: Client): import("viem/account-abstraction").BundlerClient<import("viem").HttpTransport<undefined, false>, undefined, undefined, Client, undefined>;
-export { encode7579Calls, getAccountNonce, getBundlerClient, createTransport };
-export type { ValidatorConfig };
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/accounts/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../accounts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAgBhD,OAAO,KAAK,EAAkC,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE5C,KAAK,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAErD,UAAU,eAAe;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,UAAU,aAAa,CAAC,QAAQ,SAAS,QAAQ;IAC/C,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,UAAU,oBAAoB,CAAC,QAAQ,SAAS,QAAQ;IACtD,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IAC7B,QAAQ,EAAE,SAAS;QACjB,EAAE,EAAE,OAAO,CAAA;QACX,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;KACvB,EAAE,CAAA;CACJ;AAED,UAAU,qBAAqB;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAkDD,iBAAS,eAAe,CAAC,QAAQ,SAAS,QAAQ,EAAE,EAClD,IAAI,EACJ,QAAQ,GACT,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAuFtC;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAmCjB;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,6IAuDjE;AAyBD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAA;AAC9E,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/dist/src/accounts/utils.js

@@ -1,202 +0,0 @@
-import { concatHex, encodeAbiParameters, encodeFunctionData, encodePacked, http, toBytes, toHex, } from 'viem';
-import { createBundlerClient, createPaymasterClient, } from 'viem/account-abstraction';
-import { readContract } from 'viem/actions';
-import { getAction } from 'viem/utils';
-import { createTransport } from './json-rpc/index.js';
-function parseCallType(callType) {
-    switch (callType) {
-        case 'call':
-            return '0x00';
-        case 'batchcall':
-            return '0x01';
-        case 'delegatecall':
-            return '0xff';
-    }
-}
-function encodeExecutionMode({ type, revertOnError, selector, context, }) {
-    return encodePacked(['bytes1', 'bytes1', 'bytes4', 'bytes4', 'bytes22'], [
-        toHex(toBytes(parseCallType(type), { size: 1 })),
-        toHex(toBytes(revertOnError ? '0x01' : '0x00', { size: 1 })),
-        toHex(toBytes('0x0', { size: 4 })),
-        toHex(toBytes(selector ?? '0x', { size: 4 })),
-        toHex(toBytes(context ?? '0x', { size: 22 })),
-    ]);
-}
-function encode7579Calls({ mode, callData, }) {
-    if (callData.length > 1 && mode?.type !== 'batchcall') {
-        throw new Error(`mode ${JSON.stringify(mode)} does not supported for batchcall calldata`);
-    }
-    const executeAbi = [
-        {
-            type: 'function',
-            name: 'execute',
-            inputs: [
-                {
-                    name: 'execMode',
-                    type: 'bytes32',
-                    internalType: 'ExecMode',
-                },
-                {
-                    name: 'executionCalldata',
-                    type: 'bytes',
-                    internalType: 'bytes',
-                },
-            ],
-            outputs: [],
-            stateMutability: 'payable',
-        },
-    ];
-    if (callData.length > 1) {
-        return encodeFunctionData({
-            abi: executeAbi,
-            functionName: 'execute',
-            args: [
-                encodeExecutionMode(mode),
-                encodeAbiParameters([
-                    {
-                        name: 'executionBatch',
-                        type: 'tuple[]',
-                        components: [
-                            {
-                                name: 'target',
-                                type: 'address',
-                            },
-                            {
-                                name: 'value',
-                                type: 'uint256',
-                            },
-                            {
-                                name: 'callData',
-                                type: 'bytes',
-                            },
-                        ],
-                    },
-                ], [
-                    callData.map((arg) => {
-                        return {
-                            target: arg.to,
-                            value: arg.value ?? 0n,
-                            callData: arg.data ?? '0x',
-                        };
-                    }),
-                ]),
-            ],
-        });
-    }
-    const call = callData.length === 0 ? undefined : callData[0];
-    if (!call) {
-        throw new Error('No calls to encode');
-    }
-    return encodeFunctionData({
-        abi: executeAbi,
-        functionName: 'execute',
-        args: [
-            encodeExecutionMode(mode),
-            concatHex([
-                call.to,
-                toHex(call.value ?? 0n, { size: 32 }),
-                call.data ?? '0x',
-            ]),
-        ],
-    });
-}
-async function getAccountNonce(client, args) {
-    const { address, entryPointAddress, key = 0n } = args;
-    return await getAction(client, readContract, 'readContract')({
-        address: entryPointAddress,
-        abi: [
-            {
-                inputs: [
-                    {
-                        name: 'sender',
-                        type: 'address',
-                    },
-                    {
-                        name: 'key',
-                        type: 'uint192',
-                    },
-                ],
-                name: 'getNonce',
-                outputs: [
-                    {
-                        name: 'nonce',
-                        type: 'uint256',
-                    },
-                ],
-                stateMutability: 'view',
-                type: 'function',
-            },
-        ],
-        functionName: 'getNonce',
-        args: [address, key],
-    });
-}
-function getBundlerClient(config, client) {
-    function getBundlerEndpoint(config, chainId) {
-        switch (config.type) {
-            case 'pimlico':
-                return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${config.apiKey}`;
-            case 'biconomy':
-                return `https://bundler.biconomy.io/api/v3/${chainId}/${config.apiKey}`;
-            case 'custom':
-                return typeof config.url === 'string' ? config.url : config.url[chainId];
-        }
-    }
-    function getPaymasterEndpoint(config, chainId) {
-        switch (config.type) {
-            case 'pimlico':
-                return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${config.apiKey}`;
-            case 'biconomy':
-                return `https://paymaster.biconomy.io/api/v2/${chainId}/${config.apiKey}`;
-            case 'custom':
-                return typeof config.url === 'string' ? config.url : config.url[chainId];
-        }
-    }
-    const { bundler, paymaster } = config;
-    const chainId = client.chain?.id;
-    if (!chainId) {
-        throw new Error('Chain id is required');
-    }
-    const endpoint = bundler
-        ? getBundlerEndpoint(bundler, chainId)
-        : `https://public.pimlico.io/v2/${chainId}/rpc`;
-    const paymasterEndpoint = paymaster
-        ? getPaymasterEndpoint(paymaster, chainId)
-        : undefined;
-    const isCustomBundler = bundler?.type === 'custom';
-    return createBundlerClient({
-        client,
-        transport: http(endpoint),
-        paymaster: paymasterEndpoint
-            ? createPaymasterClient({
-                transport: http(paymasterEndpoint),
-            })
-            : undefined,
-        userOperation: isCustomBundler
-            ? undefined
-            : {
-                estimateFeesPerGas: () => getGasPriceEstimate(endpoint),
-            },
-    });
-}
-async function getGasPriceEstimate(bundlerUrl) {
-    const response = await fetch(bundlerUrl, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            jsonrpc: '2.0',
-            id: Date.now(),
-            // TODO do not rely on vendor-specific methods
-            method: 'pimlico_getUserOperationGasPrice',
-            params: [],
-        }),
-    });
-    const json = (await response.json());
-    return {
-        maxFeePerGas: BigInt(json.result.fast.maxFeePerGas),
-        maxPriorityFeePerGas: BigInt(json.result.fast.maxPriorityFeePerGas),
-    };
-}
-export { encode7579Calls, getAccountNonce, getBundlerClient, createTransport };

package/dist/src/auth/provider.d.ts

@@ -1,7 +0,0 @@
-import type { RhinestoneConfig, RhinestoneSDKConfig } from '../types.js';
-export interface AuthProvider {
-    getHeaders(): Promise<Record<string, string>>;
-    getSubmitHeaders(intentInput: unknown, isSponsored: boolean): Promise<Record<string, string>>;
-}
-export declare function createAuthProvider(config: RhinestoneSDKConfig | RhinestoneConfig): AuthProvider;
-//# sourceMappingURL=provider.d.ts.map

package/dist/src/auth/provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../auth/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,UAAU,CAAA;AAEjB,MAAM,WAAW,YAAY;IAC3B,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC7C,gBAAgB,CACd,WAAW,EAAE,OAAO,EACpB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CACnC;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,mBAAmB,GAAG,gBAAgB,GAC7C,YAAY,CAqCd"}

package/dist/src/auth/provider.js

@@ -1,38 +0,0 @@
-export function createAuthProvider(config) {
-    const resolved = resolveAuth(config);
-    if (resolved.mode === 'apiKey') {
-        const headers = { 'x-api-key': resolved.apiKey };
-        return {
-            getHeaders: async () => headers,
-            getSubmitHeaders: async () => headers,
-        };
-    }
-    const { accessToken, getIntentExtensionToken } = resolved;
-    const resolveAccessToken = async () => typeof accessToken === 'function' ? await accessToken() : accessToken;
-    return {
-        async getHeaders() {
-            const token = await resolveAccessToken();
-            return { Authorization: `Bearer ${token}`, 'x-api-key': 'jwt' };
-        },
-        async getSubmitHeaders(intentInput, isSponsored) {
-            const token = await resolveAccessToken();
-            const headers = {
-                Authorization: `Bearer ${token}`,
-                'x-api-key': 'jwt',
-            };
-            if (isSponsored && getIntentExtensionToken) {
-                const extensionToken = await getIntentExtensionToken(intentInput);
-                headers['X-Intent-Extension'] = `Bearer ${extensionToken}`;
-            }
-            return headers;
-        },
-    };
-}
-function resolveAuth(config) {
-    if ('auth' in config && config.auth)
-        return config.auth;
-    if ('apiKey' in config && config.apiKey) {
-        return { mode: 'apiKey', apiKey: config.apiKey };
-    }
-    throw new Error('RhinestoneSDK requires either `apiKey` or `auth` in config');
-}