Placing dShare Orders with Safe Vaults

import Dinari from "@dinari/api-sdk";
import Safe from "@safe-global/protocol-kit";

const dinariCredentials = await loadDinariCredentialsFromSecretManager();
const walletSecrets = await loadWalletSecretsFromSecretManager();
const config = await loadChainConfig();

const dinari = new Dinari({
  apiKeyID: dinariCredentials.apiKeyID,
  apiSecretKey: dinariCredentials.apiSecretKey,
  environment: "sandbox", // defaults to "production"
});

const safe = await Safe.init({
  provider: config.rpcUrl,
  signer: walletSecrets.ownerPrivateKey, // a Safe owner
  safeAddress: config.safeAddress,
});

if (!(await safe.isSafeDeployed())) {
  throw new Error("Deploy the Safe before signing permits");
}

const safeAddress = await safe.getAddress();

const entity = await dinari.v2.entities.create({ name: "Jane Doe" });
const kyc = await dinari.v2.entities.kyc.createManagedCheck(entity.id);
console.log("Send the user to:", kyc.embed_url);

const account = await dinari.v2.entities.accounts.create(entity.id);
const accountId = account.id;

const nonceResp = await dinari.v2.accounts.wallet.external.getNonce(accountId, {
  wallet_address: safeAddress,
});

const linkMessage = await safe.signMessage(safe.createMessage(nonceResp.message));

await dinari.v2.accounts.wallet.external.connect(accountId, {
  chain_id: "eip155:421614",
  nonce: nonceResp.nonce,
  signature: linkMessage.encodedSignatures(),
  wallet_address: safeAddress,
});

import { encodeFunctionData, erc20Abi, maxUint256 } from "viem";

const PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";

const approveTx = await safe.createTransaction({
  transactions: [
    {
      to: config.paymentTokenAddress,
      value: "0",
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: "approve",
        args: [PERMIT2, maxUint256],
      }),
    },
  ],
});

await safe.executeTransaction(await safe.signTransaction(approveTx));

const stocks = await dinari.v2.marketData.stocks.list();
const stock = stocks.find((s) => s.symbol === "AAPL");
if (!stock) throw new Error("Stock not found");
const stockId = stock.id;

const permitResponse = await dinari.v2.accounts.orderRequests.eip155.createPermit(
  accountId,
  {
    chain_id: "eip155:421614",
    order_side: "BUY",
    order_type: "MARKET",
    order_tif: "DAY",
    stock_id: stockId,
    payment_token: config.paymentTokenAddress,
    payment_token_quantity: 10.0,
  },
);

const orderRequestId = permitResponse.order_request_id;
const permit = permitResponse.permit; // { domain, types, primaryType, message }

if (permit.primaryType === "Permit") {
  throw new Error("Got an ERC-2612 permit. Approve Permit2 from the Safe (Step 3).");
}

let signedPermit = await safe.signMessage(
  safe.createMessage({
    domain: permit.domain,
    types: permit.types,
    primaryType: permit.primaryType,
    message: permit.message,
  }),
);

// For threshold > 1, add each remaining owner's signature:
for (const ownerKey of walletSecrets.additionalOwnerKeys) {
  const ownerSafe = await safe.connect({ signer: ownerKey });
  signedPermit = await ownerSafe.signMessage(signedPermit);
}

const permitSignature = signedPermit.encodedSignatures();

const tx = await dinari.v2.accounts.orderRequests.eip155.createPermitTransaction(
  accountId,
  { order_request_id: orderRequestId, permit_signature: permitSignature },
);

const orderTx = await safe.createTransaction({
  transactions: [
    { to: tx.contract_address, data: tx.data, value: tx.value ?? "0" },
  ],
});

const result = await safe.executeTransaction(await safe.signTransaction(orderTx));
console.log("Tx hash:", result.hash);

const orderRequest = await dinari.v2.accounts.orderRequests.retrieve(
  orderRequestId,
  { account_id: accountId },
);
console.log("Status:", orderRequest.status);