@rhinestone/sdk 0.7.8 → 0.7.10

package/dist/cjs/orchestrator/utils.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleStatusEnum = void 0;
+exports.getEmptyUserOp = getEmptyUserOp;
+exports.getOrderBundleHash = getOrderBundleHash;
+exports.convertBigIntFields = convertBigIntFields;
+exports.parseCompactResponse = parseCompactResponse;
+exports.parsePendingBundleEvent = parsePendingBundleEvent;
+exports.hashMultichainCompactWithoutDomainSeparator = hashMultichainCompactWithoutDomainSeparator;
+exports.parseUseChainBalances = parseUseChainBalances;
+exports.parseOrderCost = parseOrderCost;
+exports.parseInsufficientBalanceResult = parseInsufficientBalanceResult;
+exports.parseOrderCostResult = parseOrderCostResult;
+exports.applyInjectedExecutions = applyInjectedExecutions;
+const viem_1 = require("viem");
+const modules_1 = require("../modules");
+const types_1 = require("./types");
+const MULTICHAIN_COMPACT_TYPEHASH = '0xee54591377b86e048be6b2fbd8913598a6270aed3415776321279495bf4efae5';
+const SEGMENT_TYPEHASH = '0x54ada5b33a7390e2883c985295cfa2dcd9bb46515ad10cbdfc22a7c73f9807db';
+const WITNESS_TYPEHASH = '0x78e29a727cef567e7d6dddf5bf7eedf0c84af60d4a57512c586c787aae731629';
+const EXECUTION_TYPEHASH = '0xa222cbaaad3b88446c3ca031429dafb24afdbda10c5dbd9882c294762857141a';
+var BundleStatusEnum;
+(function (BundleStatusEnum) {
+    BundleStatusEnum["PENDING"] = "PENDING";
+    BundleStatusEnum["EXPIRED"] = "EXPIRED";
+    BundleStatusEnum["PARTIALLY_COMPLETED"] = "PARTIALLY_COMPLETED";
+    BundleStatusEnum["PRECONFIRMED"] = "PRECONFIRMED";
+    BundleStatusEnum["COMPLETED"] = "COMPLETED";
+    BundleStatusEnum["FILLED"] = "FILLED";
+    BundleStatusEnum["FAILED"] = "FAILED";
+    BundleStatusEnum["UNKNOWN"] = "UNKNOWN";
+})(BundleStatusEnum || (exports.BundleStatusEnum = BundleStatusEnum = {}));
+function getEmptyUserOp() {
+    return {
+        sender: viem_1.zeroAddress,
+        nonce: 0n,
+        callData: '0x',
+        preVerificationGas: 0n,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        verificationGasLimit: 0n,
+        callGasLimit: 0n,
+        signature: '0x',
+    };
+}
+function getOrderBundleHash(orderBundle) {
+    const notarizedChainId = Number(orderBundle.segments[0].chainId);
+    return hashMultiChainCompactWithDomainSeparator(orderBundle, getCompactDomainSeparator(notarizedChainId, modules_1.HOOK_ADDRESS));
+}
+function convertBigIntFields(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj === 'bigint') {
+        return obj.toString();
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(convertBigIntFields);
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const key in obj) {
+            if (Object.hasOwn(obj, key)) {
+                result[key] = convertBigIntFields(obj[key]);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function parseCompactResponse(response) {
+    return {
+        sponsor: response.sponsor,
+        nonce: BigInt(response.nonce),
+        expires: BigInt(response.expires),
+        segments: response.segments.map((segment) => {
+            return {
+                arbiter: segment.arbiter,
+                chainId: BigInt(segment.chainId),
+                idsAndAmounts: segment.idsAndAmounts.map((idsAndAmount) => {
+                    return [BigInt(idsAndAmount[0]), BigInt(idsAndAmount[1])];
+                }),
+                witness: {
+                    recipient: segment.witness.recipient,
+                    tokenOut: segment.witness.tokenOut.map((tokenOut) => {
+                        return [BigInt(tokenOut[0]), BigInt(tokenOut[1])];
+                    }),
+                    depositId: BigInt(segment.witness.depositId),
+                    targetChain: BigInt(segment.witness.targetChain),
+                    fillDeadline: segment.witness.fillDeadline,
+                    execs: segment.witness.execs.map((exec) => {
+                        return {
+                            to: exec.to,
+                            value: BigInt(exec.value),
+                            data: exec.data,
+                        };
+                    }),
+                    userOpHash: segment.witness.userOpHash,
+                    maxFeeBps: segment.witness.maxFeeBps,
+                },
+            };
+        }),
+    };
+}
+function parseUseChainBalances(response) {
+    const result = {};
+    for (const chainIdStr in response) {
+        const chainId = Number(chainIdStr);
+        const chainData = response[chainIdStr];
+        result[chainId] = {};
+        for (const tokenAddress in chainData) {
+            const balanceStr = chainData[tokenAddress]?.balance;
+            result[chainId][tokenAddress] = BigInt(balanceStr);
+        }
+    }
+    return result;
+}
+function parseOrderCost(response) {
+    const tokensSpent = {};
+    for (const chainIdStr in response.tokensSpent) {
+        const chainId = Number(chainIdStr);
+        tokensSpent[chainId] = {};
+        const chainTokens = response.tokensSpent[chainIdStr];
+        for (const tokenAddress in chainTokens) {
+            const balanceStr = chainTokens[tokenAddress];
+            if (typeof balanceStr !== 'string') {
+                throw new Error(`Expected string balance for token ${tokenAddress} on chain ${chainId}`);
+            }
+            tokensSpent[chainId][tokenAddress] = BigInt(balanceStr);
+        }
+    }
+    const tokensReceived = response.tokensReceived.map((entry) => {
+        return {
+            tokenAddress: entry.tokenAddress,
+            hasFulfilled: entry.hasFulfilled,
+            amountSpent: BigInt(entry.amountSpent),
+            targetAmount: BigInt(entry.targetAmount),
+            fee: BigInt(entry.fee),
+        };
+    });
+    return {
+        hasFulfilledAll: true,
+        tokensSpent,
+        tokensReceived,
+    };
+}
+function parseInsufficientBalanceResult(response) {
+    if (!Array.isArray(response.tokenShortfall)) {
+        throw new Error('Expected tokenShortfall to be an array');
+    }
+    const tokenShortfall = response.tokenShortfall.map((entry) => {
+        return {
+            tokenAddress: entry.tokenAddress,
+            targetAmount: BigInt(entry.targetAmount),
+            amountSpent: BigInt(entry.amountSpent),
+            fee: BigInt(entry.fee),
+            tokenSymbol: entry.tokenSymbol,
+            tokenDecimals: entry.tokenDecimals,
+        };
+    });
+    const result = {
+        hasFulfilledAll: false,
+        tokenShortfall,
+        totalTokenShortfallInUSD: BigInt(response.totalTokenShortfallInUSD),
+    };
+    return result;
+}
+function parseOrderCostResult(response) {
+    if (typeof response.hasFulfilledAll !== 'boolean') {
+        throw new Error('Missing or invalid hasFulfilledAll field');
+    }
+    if (response.hasFulfilledAll) {
+        return parseOrderCost(response);
+    }
+    else {
+        return parseInsufficientBalanceResult(response);
+    }
+}
+function parsePendingBundleEvent(response) {
+    return {
+        type: response.type,
+        bundleId: BigInt(response.bundleId),
+        targetFillPayload: {
+            to: response.targetFillPayload.to,
+            data: response.targetFillPayload.data,
+            value: BigInt(response.targetFillPayload.value),
+            chainId: response.targetFillPayload.chainId,
+        },
+        acrossDepositEvents: response.acrossDepositEvents.map((event) => {
+            return {
+                message: event.message,
+                depositId: BigInt(event.depositId),
+                depositor: event.depositor,
+                recipient: event.recipient,
+                inputToken: event.inputToken,
+                inputAmount: BigInt(event.inputAmount),
+                outputToken: event.outputToken,
+                fillDeadline: event.fillDeadline,
+                outputAmount: BigInt(event.outputAmount),
+                quoteTimestamp: event.quoteTimestamp,
+                exclusiveRelayer: event.exclusiveRelayer,
+                destinationChainId: event.destinationChainId,
+                originClaimPayload: {
+                    to: event.originClaimPayload.to,
+                    data: event.originClaimPayload.data,
+                    value: BigInt(event.originClaimPayload.value),
+                    chainId: event.originClaimPayload.chainId,
+                },
+                exclusivityDeadline: event.exclusivityDeadline,
+            };
+        }),
+    };
+}
+function hashMultiChainCompactWithDomainSeparator(multiChainCompact, domainSeparator) {
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string', 'bytes32', 'bytes32'], [
+        '\x19\x01',
+        domainSeparator,
+        hashMultichainCompactWithoutDomainSeparator(multiChainCompact),
+    ]));
+}
+function hashMultichainCompactWithoutDomainSeparator(multiChainCompact) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typehash', type: 'bytes32' },
+        { name: 'sponsor', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'expires', type: 'uint256' },
+        { name: 'segments', type: 'bytes32' },
+    ], [
+        MULTICHAIN_COMPACT_TYPEHASH,
+        multiChainCompact.sponsor,
+        multiChainCompact.nonce,
+        multiChainCompact.expires,
+        hashSegments([...multiChainCompact.segments]),
+    ]));
+}
+function hashSegments(segment) {
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32[]'], [segment.map(hashSegment)]));
+}
+function hashSegment(segment) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typehash', type: 'bytes32' },
+        { name: 'arbiter', type: 'address' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'idsAndAmounts', type: 'bytes32' },
+        { name: 'witness', type: 'bytes32' },
+    ], [
+        SEGMENT_TYPEHASH,
+        segment.arbiter,
+        segment.chainId,
+        hashIdsAndAmounts(segment.idsAndAmounts),
+        hashWitness(segment.witness),
+    ]));
+}
+function hashWitness(witness) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typehash', type: 'bytes32' },
+        { name: 'recipient', type: 'address' },
+        { name: 'tokenOut', type: 'bytes32' },
+        { name: 'depositId', type: 'uint256' },
+        { name: 'targetChain', type: 'uint256' },
+        { name: 'fillDeadline', type: 'uint32' },
+        { name: 'execs', type: 'bytes32' }, // Assuming XchainExec[] is complex
+        { name: 'userOpHash', type: 'bytes32' },
+        { name: 'maxFeeBps', type: 'uint32' },
+    ], [
+        WITNESS_TYPEHASH,
+        witness.recipient,
+        hashIdsAndAmounts(witness.tokenOut),
+        witness.depositId,
+        witness.targetChain,
+        witness.fillDeadline,
+        hashExecutionArray(witness.execs),
+        witness.userOpHash,
+        witness.maxFeeBps,
+    ]));
+}
+function getCompactDomainSeparator(chainId, verifyingContract) {
+    return (0, viem_1.domainSeparator)({
+        domain: getCompactDomain(chainId, verifyingContract),
+    });
+}
+function getCompactDomain(chainId, verifyingContract) {
+    return {
+        name: 'The Compact',
+        version: '0',
+        chainId: chainId,
+        verifyingContract: verifyingContract,
+    };
+}
+function hashIdsAndAmounts(idsAndAmounts) {
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['uint256[2][]'], [idsAndAmounts]));
+}
+function hashExecutionArray(executionArray) {
+    const hashes = executionArray.map(hashExecution);
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32[]'], [hashes]));
+}
+function hashExecution(execution) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typehash', type: 'bytes32' },
+        { name: 'target', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'callData', type: 'bytes32' },
+    ], [
+        EXECUTION_TYPEHASH,
+        execution.to,
+        execution.value,
+        (0, viem_1.keccak256)(execution.data),
+    ]));
+}
+function applyInjectedExecutions(orderPath) {
+    if (orderPath.injectedExecutions.length > 0) {
+        orderPath.orderBundle.segments[0].witness.execs =
+            orderPath.injectedExecutions.concat(orderPath.orderBundle.segments[0].witness.execs);
+    }
+    return orderPath.orderBundle;
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,113 @@
+import type { Account, Address, Chain, Hex } from 'viem';
+import type { WebAuthnAccount } from 'viem/account-abstraction';
+interface AccountProviderConfig {
+    type: 'safe' | 'nexus';
+}
+interface OwnableValidatorConfig {
+    type: 'ecdsa';
+    accounts: Account[];
+    threshold?: number;
+}
+interface WebauthnValidatorConfig {
+    type: 'passkey';
+    account: WebAuthnAccount;
+}
+interface BundlerConfig {
+    type: 'pimlico';
+    apiKey: string;
+}
+type OwnerSet = OwnableValidatorConfig | WebauthnValidatorConfig;
+interface SudoPolicy {
+    type: 'sudo';
+}
+interface UniversalActionPolicy {
+    type: 'universal-action';
+    valueLimitPerUse?: bigint;
+    rules: [UniversalActionPolicyParamRule, ...UniversalActionPolicyParamRule[]];
+}
+interface UniversalActionPolicyParamRule {
+    condition: UniversalActionPolicyParamCondition;
+    calldataOffset: bigint;
+    usageLimit?: bigint;
+    referenceValue: Hex | bigint;
+}
+type UniversalActionPolicyParamCondition = 'equal' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'notEqual' | 'inRange';
+interface SpendingLimitsPolicy {
+    type: 'spending-limits';
+    limits: {
+        token: Address;
+        amount: bigint;
+    }[];
+}
+interface TimeFramePolicy {
+    type: 'time-frame';
+    validUntil: number;
+    validAfter: number;
+}
+interface UsageLimitPolicy {
+    type: 'usage-limit';
+    limit: bigint;
+}
+interface ValueLimitPolicy {
+    type: 'value-limit';
+    limit: bigint;
+}
+type Policy = SudoPolicy | UniversalActionPolicy | SpendingLimitsPolicy | TimeFramePolicy | UsageLimitPolicy | ValueLimitPolicy;
+interface Action {
+    target: Address;
+    selector: Hex;
+    policies?: [Policy, ...Policy[]];
+}
+interface Session {
+    owners: OwnerSet;
+    policies?: [Policy, ...Policy[]];
+    actions?: [Action, ...Action[]];
+    salt?: Hex;
+}
+interface RhinestoneAccountConfig {
+    account?: AccountProviderConfig;
+    owners: OwnerSet;
+    rhinestoneApiKey: string;
+    deployerAccount?: Account;
+    sessions?: Session[];
+    eoa?: Account;
+    provider?: {
+        type: 'alchemy';
+        apiKey: string;
+    };
+    bundler?: BundlerConfig;
+}
+interface Call {
+    to: Address;
+    data?: Hex;
+    value?: bigint;
+}
+/**
+ * @deprecated Use the `Call` type instead.
+ */
+type Execution = Call;
+interface TokenRequest {
+    address: Address;
+    amount: bigint;
+}
+interface SessionSignerSet {
+    type: 'session';
+    session: Session;
+}
+type SignerSet = SessionSignerSet;
+interface BaseTransaction {
+    calls: Call[];
+    tokenRequests: TokenRequest[];
+    gasLimit?: bigint;
+    signers?: SignerSet;
+}
+interface SameChainTransaction extends BaseTransaction {
+    chain: Chain;
+}
+interface CrossChainTransaction extends BaseTransaction {
+    sourceChain?: Chain;
+    targetChain: Chain;
+}
+type Transaction = SameChainTransaction | CrossChainTransaction;
+export type { RhinestoneAccountConfig, AccountProviderConfig, BundlerConfig, Transaction, Call, Execution, TokenRequest, OwnerSet, SignerSet, Session, Policy, UniversalActionPolicyParamCondition, };
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/types.d.ts.map

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

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/execution/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIV,KAAK,GAAG,EAMT,MAAM,MAAM,CAAA;AAmBb,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,iBAAiB,CAAA;AAiBxB,OAAO,KAAK,EAEV,uBAAuB,EAIvB,WAAW,EACZ,MAAM,UAAU,CAAA;AASjB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AAwRD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GA2CjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,yDAMpB;AASD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIV,KAAK,GAAG,EAMT,MAAM,MAAM,CAAA;AAmBb,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,iBAAiB,CAAA;AAiBxB,OAAO,KAAK,EAEV,uBAAuB,EAIvB,WAAW,EACZ,MAAM,UAAU,CAAA;AASjB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AAwRD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GAwCjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,yDAMpB;AASD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/execution/index.js

@@ -192,19 +192,18 @@ async function sendTransactionAsIntent(config, sourceChain, targetChain, calls,
     };
 }
 async function waitForExecution(config, result, acceptsPreconfirmations) {
-    const validStatuses = [
+    const validStatuses = new Set([
         BUNDLE_STATUS_FAILED,
         BUNDLE_STATUS_COMPLETED,
         BUNDLE_STATUS_FILLED,
-    ];
+    ]);
     if (acceptsPreconfirmations) {
-        validStatuses.push(BUNDLE_STATUS_PRECONFIRMED);
+        validStatuses.add(BUNDLE_STATUS_PRECONFIRMED);
     }
     switch (result.type) {
         case 'bundle': {
             let bundleResult = null;
-            while (bundleResult === null ||
-                validStatuses.includes(bundleResult.status)) {
+            while (bundleResult === null || !validStatuses.has(bundleResult.status)) {
                 const orchestrator = getOrchestratorByChain(result.targetChain, config.rhinestoneApiKey);
                 bundleResult = await orchestrator.getBundleStatus(result.id);
                 await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/sdk",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "End-to-end chain abstraction and modularity toolkit",
   "author": {
     "name": "Rhinestone",
@@ -24,6 +24,11 @@
       "types": "./dist/src/orchestrator/index.d.ts",
       "require": "./dist/src/orchestrator/index.js",
       "import": "./dist/src/orchestrator/index.js"
+    },
+    "./dist/cjs/orchestrator": {
+      "types": "./dist/cjs/orchestrator/index.d.ts",
+      "require": "./dist/cjs/orchestrator/index.js",
+      "import": "./dist/cjs/orchestrator/index.js"
     }
   },
   "files": [