@rhinestone/sdk 0.1.0

package/dist/services/orchestrator/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../services/orchestrator/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,GAAG,EAGJ,MAAM,MAAM,CAAA;AAGb,OAAO,EACL,WAAW,EAEX,iBAAiB,EAIlB,MAAM,SAAS,CAAA;AAYhB,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,iBAAiB,GAAG,GAAG,CAMtE;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAwBjD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,GAAG,GAAG,iBAAiB,CAiCrE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,GAAG,GAAG,WAAW,CAkClE"}

package/dist/services/orchestrator/utils.js

@@ -0,0 +1,196 @@
+import { domainSeparator, encodeAbiParameters, encodePacked, keccak256, } from 'viem';
+import { HOOK_ADDRESS } from './consts';
+const MULTICHAIN_COMPACT_TYPEHASH = '0xee54591377b86e048be6b2fbd8913598a6270aed3415776321279495bf4efae5';
+const SEGMENT_TYPEHASH = '0x54ada5b33a7390e2883c985295cfa2dcd9bb46515ad10cbdfc22a7c73f9807db';
+const WITNESS_TYPEHASH = '0x78e29a727cef567e7d6dddf5bf7eedf0c84af60d4a57512c586c787aae731629';
+const EXECUTION_TYPEHASH = '0xa222cbaaad3b88446c3ca031429dafb24afdbda10c5dbd9882c294762857141a';
+export function getOrderBundleHash(orderBundle) {
+    const notarizedChainId = Number(orderBundle.segments[0].chainId);
+    return hashMultiChainCompactWithDomainSeparator(orderBundle, getCompactDomainSeparator(notarizedChainId, HOOK_ADDRESS));
+}
+export 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.prototype.hasOwnProperty.call(obj, key)) {
+                result[key] = convertBigIntFields(obj[key]);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+export 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,
+                },
+            };
+        }),
+    };
+}
+export 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 keccak256(encodePacked(['string', 'bytes32', 'bytes32'], [
+        '\x19\x01',
+        domainSeparator,
+        hashMultichainCompactWithoutDomainSeparator(multiChainCompact),
+    ]));
+}
+function hashMultichainCompactWithoutDomainSeparator(multiChainCompact) {
+    return keccak256(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 keccak256(encodePacked(['bytes32[]'], [segment.map(hashSegment)]));
+}
+function hashSegment(segment) {
+    return keccak256(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 keccak256(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 domainSeparator({
+        domain: getCompactDomain(chainId, verifyingContract),
+    });
+}
+function getCompactDomain(chainId, verifyingContract) {
+    return {
+        name: 'The Compact',
+        version: '0',
+        chainId: chainId,
+        verifyingContract: verifyingContract,
+    };
+}
+function hashIdsAndAmounts(idsAndAmounts) {
+    return keccak256(encodePacked(['uint256[2][]'], [idsAndAmounts]));
+}
+function hashExecutionArray(executionArray) {
+    const hashes = executionArray.map(hashExecution);
+    return keccak256(encodePacked(['bytes32[]'], [hashes]));
+}
+function hashExecution(execution) {
+    return keccak256(encodeAbiParameters([
+        { name: 'typehash', type: 'bytes32' },
+        { name: 'target', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'callData', type: 'bytes32' },
+    ], [
+        EXECUTION_TYPEHASH,
+        execution.to,
+        execution.value,
+        keccak256(execution.data),
+    ]));
+}

package/dist/services/transaction.d.ts

@@ -0,0 +1,6 @@
+import { type BundleResult } from './orchestrator';
+import { RhinestoneAccountConfig, Transaction } from '../types';
+declare function sendTransactions(config: RhinestoneAccountConfig, transaction: Transaction): Promise<bigint>;
+declare function waitForExecution(config: RhinestoneAccountConfig, id: bigint): Promise<BundleResult>;
+export { sendTransactions, waitForExecution };
+//# sourceMappingURL=transaction.d.ts.map

package/dist/services/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../services/transaction.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,YAAY,EAQlB,MAAM,gBAAgB,CAAA;AAQvB,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAY,MAAM,UAAU,CAAA;AAEzE,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,mBAiEzB;AAED,iBAAe,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,EAAE,EAAE,MAAM,yBAa1E;AAmCD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/services/transaction.js

@@ -0,0 +1,93 @@
+import { concat, encodePacked } from 'viem';
+import { BUNDLE_STATUS_PENDING, BUNDLE_STATUS_FAILED, getOrchestrator, getOrderBundleHash, } from './orchestrator';
+import { getAddress, getDeployArgs, isDeployed, deploy } from './account';
+import { getValidator, getWebauthnValidatorSignature, isRip7212SupportedNetwork, } from './modules';
+async function sendTransactions(config, transaction) {
+    const { sourceChain, targetChain, calls, tokenRequests } = transaction;
+    const isAccountDeployed = await isDeployed(sourceChain, config);
+    if (!isAccountDeployed) {
+        await deploy(config.deployerAccount, sourceChain, config);
+    }
+    const accountAddress = await getAddress(config);
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        targetExecutions: calls.map((call) => ({
+            value: call.value ?? 0n,
+            to: call.to,
+            data: call.data ?? '0x',
+        })),
+    };
+    const orchestrator = getOrchestrator(config.rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    orderPath[0].orderBundle.segments[0].witness.execs = [
+        ...orderPath[0].injectedExecutions,
+        ...metaIntent.targetExecutions,
+    ];
+    const orderBundleHash = getOrderBundleHash(orderPath[0].orderBundle);
+    const bundleSignature = await sign(config.owners, sourceChain, orderBundleHash);
+    const validatorModule = getValidator(config);
+    const packedSig = encodePacked(['address', 'bytes'], [validatorModule.address, bundleSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    const { factory, factoryData } = await getDeployArgs(config);
+    if (!factory || !factoryData) {
+        throw new Error('Factory args not available');
+    }
+    const initCode = encodePacked(['address', 'bytes'], [factory, factoryData]);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            initCode,
+        },
+    ]);
+    return bundleResults[0].bundleId;
+}
+async function waitForExecution(config, id) {
+    let bundleResult = null;
+    while (bundleResult === null ||
+        bundleResult.status === BUNDLE_STATUS_PENDING) {
+        const orchestrator = getOrchestrator(config.rhinestoneApiKey);
+        bundleResult = await orchestrator.getBundleStatus(id);
+    }
+    if (bundleResult.status === BUNDLE_STATUS_FAILED) {
+        throw new Error('Bundle failed');
+    }
+    return bundleResult;
+}
+async function sign(validators, chain, hash) {
+    switch (validators.type) {
+        case 'ecdsa': {
+            const signatures = await Promise.all(validators.accounts.map((account) => signEcdsa(account, hash)));
+            return concat(signatures);
+        }
+        case 'passkey': {
+            return await signPasskey(validators.account, chain, hash);
+        }
+    }
+}
+async function signEcdsa(account, hash) {
+    const sign = account.signMessage;
+    if (!sign) {
+        throw new Error('Signing not supported for the account');
+    }
+    return await sign({ message: { raw: hash } });
+}
+async function signPasskey(account, chain, hash) {
+    const { webauthn, signature } = await account.sign({ hash });
+    const usePrecompiled = isRip7212SupportedNetwork(chain);
+    const encodedSignature = getWebauthnValidatorSignature({
+        webauthn,
+        signature,
+        usePrecompiled,
+    });
+    return encodedSignature;
+}
+export { sendTransactions, waitForExecution };

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import { Account, Address, Chain, Hex } from 'viem';
+import { WebAuthnAccount } from 'viem/account-abstraction';
+interface OwnableValidatorConfig {
+    type: 'ecdsa';
+    accounts: Account[];
+    threshold?: number;
+}
+interface WebauthnValidatorConfig {
+    type: 'passkey';
+    account: WebAuthnAccount;
+}
+type OwnerSet = OwnableValidatorConfig | WebauthnValidatorConfig;
+interface RhinestoneAccountConfig {
+    account: {
+        type: 'safe';
+    };
+    owners: OwnerSet;
+    rhinestoneApiKey: string;
+    deployerAccount: Account;
+    provider?: {
+        type: 'alchemy';
+        apiKey: string;
+    };
+    bundler?: {
+        type: 'pimlico';
+        apiKey: string;
+    };
+}
+interface Call {
+    to: Address;
+    data?: Hex;
+    value?: bigint;
+}
+interface TokenRequest {
+    address: Address;
+    amount: bigint;
+}
+interface Transaction {
+    sourceChain: Chain;
+    targetChain: Chain;
+    calls: Call[];
+    tokenRequests: TokenRequest[];
+}
+export type { RhinestoneAccountConfig, Transaction, OwnerSet };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE1D,UAAU,sBAAsB;IAC9B,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,uBAAuB;IAC/B,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,eAAe,CAAA;CACzB;AAED,KAAK,QAAQ,GAAG,sBAAsB,GAAG,uBAAuB,CAAA;AAChE,UAAU,uBAAuB;IAC/B,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,QAAQ,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,SAAS,CAAA;QACf,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IACD,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,SAAS,CAAA;QACf,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,UAAU,IAAI;IACZ,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,UAAU,WAAW;IACnB,WAAW,EAAE,KAAK,CAAA;IAClB,WAAW,EAAE,KAAK,CAAA;IAClB,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B;AAED,YAAY,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAA"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rhinestone/sdk",
+  "version": "0.1.0",
+  "description": "End-to-end chain abstraction and modularity toolkit",
+  "author": {
+    "name": "Rhinestone",
+    "url": "https://rhinestone.wtf"
+  },
+  "keywords": [
+    "ethereum",
+    "rhinestone",
+    "sdk"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://docs.rhinestone.wtf/",
+  "bugs": {
+    "url": "https://github.com/rhinestonewtf/sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rhinestonewtf/sdk.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.7.0"
+  },
+  "peerDependencies": {
+    "viem": "^2.20.0"
+  }
+}